librpc/rpc/binding_handle.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    dcerpc binding handle functions
   5
   6    Copyright (C) Stefan Metzmacher 2010
   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 <tevent.h>
  24 #include "../lib/util/tevent_ntstatus.h"
  25 #include "librpc/rpc/dcerpc.h"
  26 #include "rpc_common.h"
  27
  28 struct dcerpc_binding_handle {
  29         void *private_data;
  30         const struct dcerpc_binding_handle_ops *ops;
  31         const char *location;
  32         const struct GUID *object;
  33         const struct ndr_interface_table *table;
  34         struct tevent_context *sync_ev;
  35 };
  36
  37 static int dcerpc_binding_handle_destructor(struct dcerpc_binding_handle *b)
  38 {
  39         return 0;
  40 }
  41
  42 struct dcerpc_binding_handle *_dcerpc_binding_handle_create(TALLOC_CTX *mem_ctx,
  43                                         const struct dcerpc_binding_handle_ops *ops,
  44                                         const struct GUID *object,
  45                                         const struct ndr_interface_table *table,
  46                                         void *pstate,
  47                                         size_t psize,
  48                                         const char *type,
  49                                         const char *location)
  50 {
  51         struct dcerpc_binding_handle *h;
  52         void **ppstate = (void **)pstate;
  53         void *state;
  54
  55         h = talloc_zero(mem_ctx, struct dcerpc_binding_handle);
  56         if (h == NULL) {
  57                 return NULL;
  58         }
  59         h->ops          = ops;
  60         h->location     = location;
  61         h->object       = object;
  62         h->table        = table;
  63
  64         state = talloc_zero_size(h, psize);
  65         if (state == NULL) {
  66                 talloc_free(h);
  67                 return NULL;
  68         }
  69         talloc_set_name_const(state, type);
  70
  71         h->private_data = state;
  72
  73         talloc_set_destructor(h, dcerpc_binding_handle_destructor);
  74
  75         *ppstate = state;
  76         return h;
  77 }
  78
  79 void *_dcerpc_binding_handle_data(struct dcerpc_binding_handle *h)
  80 {
  81         return h->private_data;
  82 }
  83
  84 void dcerpc_binding_handle_set_sync_ev(struct dcerpc_binding_handle *h,
  85                                        struct tevent_context *ev)
  86 {
  87         h->sync_ev = ev;
  88 }
  89
  90 const struct dcerpc_binding *dcerpc_binding_handle_get_binding(struct dcerpc_binding_handle *h)
  91 {
  92         return h->ops->get_binding(h);
  93 }
  94
  95 enum dcerpc_transport_t dcerpc_binding_handle_get_transport(struct dcerpc_binding_handle *h)
  96 {
  97         const struct dcerpc_binding *b = dcerpc_binding_handle_get_binding(h);
  98         return dcerpc_binding_get_transport(b);
  99 }
 100
 101 bool dcerpc_binding_handle_is_connected(struct dcerpc_binding_handle *h)
 102 {
 103         return h->ops->is_connected(h);
 104 }
 105
 106 uint32_t dcerpc_binding_handle_set_timeout(struct dcerpc_binding_handle *h,
 107                                            uint32_t timeout)
 108 {
 109         return h->ops->set_timeout(h, timeout);
 110 }
 111
 112 bool dcerpc_binding_handle_transport_encrypted(struct dcerpc_binding_handle *h)
 113 {
 114         if (h->ops->transport_encrypted == NULL) {
 115                 return false;
 116         }
 117
 118         return h->ops->transport_encrypted(h);
 119 }
 120
 121 NTSTATUS dcerpc_binding_handle_transport_session_key(
 122                 struct dcerpc_binding_handle *h,
 123                 TALLOC_CTX *mem_ctx,
 124                 DATA_BLOB *session_key)
 125 {
 126         if (h->ops->transport_session_key == NULL) {
 127                 return NT_STATUS_NO_USER_SESSION_KEY;
 128         }
 129
 130         return h->ops->transport_session_key(h, mem_ctx, session_key);
 131 }
 132
 133 void dcerpc_binding_handle_auth_info(struct dcerpc_binding_handle *h,
 134                                      enum dcerpc_AuthType *auth_type,
 135                                      enum dcerpc_AuthLevel *auth_level)
 136 {
 137         enum dcerpc_AuthType _auth_type;
 138         enum dcerpc_AuthLevel _auth_level;
 139
 140         if (auth_type == NULL) {
 141                 auth_type = &_auth_type;
 142         }
 143
 144         if (auth_level == NULL) {
 145                 auth_level = &_auth_level;
 146         }
 147
 148         *auth_type = DCERPC_AUTH_TYPE_NONE;
 149         *auth_level = DCERPC_AUTH_LEVEL_NONE;
 150
 151         if (h->ops->auth_info == NULL) {
 152                 return;
 153         }
 154
 155         h->ops->auth_info(h, auth_type, auth_level);
 156 }
 157
 158 NTSTATUS dcerpc_binding_handle_auth_session_key(
 159                 struct dcerpc_binding_handle *h,
 160                 TALLOC_CTX *mem_ctx,
 161                 DATA_BLOB *session_key)
 162 {
 163         if (h->ops->auth_session_key == NULL) {
 164                 return NT_STATUS_NO_USER_SESSION_KEY;
 165         }
 166
 167         return h->ops->auth_session_key(h, mem_ctx, session_key);
 168 }
 169
 170 struct dcerpc_binding_handle_raw_call_state {
 171         const struct dcerpc_binding_handle_ops *ops;
 172         uint8_t *out_data;
 173         size_t out_length;
 174         uint32_t out_flags;
 175 };
 176
 177 static void dcerpc_binding_handle_raw_call_done(struct tevent_req *subreq);
 178
 179 struct tevent_req *dcerpc_binding_handle_raw_call_send(TALLOC_CTX *mem_ctx,
 180                                                 struct tevent_context *ev,
 181                                                 struct dcerpc_binding_handle *h,
 182                                                 const struct GUID *object,
 183                                                 uint32_t opnum,
 184                                                 uint32_t in_flags,
 185                                                 const uint8_t *in_data,
 186                                                 size_t in_length)
 187 {
 188         struct tevent_req *req;
 189         struct dcerpc_binding_handle_raw_call_state *state;
 190         struct tevent_req *subreq;
 191
 192         req = tevent_req_create(mem_ctx, &state,
 193                                 struct dcerpc_binding_handle_raw_call_state);
 194         if (req == NULL) {
 195                 return NULL;
 196         }
 197         state->ops = h->ops;
 198         state->out_data = NULL;
 199         state->out_length = 0;
 200         state->out_flags = 0;
 201
 202         if (h->object != NULL) {
 203                 /*
 204                  * If an object is set on the binding handle,
 205                  * per request object passing is not allowed.
 206                  */
 207                 if (object != NULL) {
 208                         tevent_req_nterror(req, NT_STATUS_INVALID_HANDLE);
 209                         return tevent_req_post(req, ev);
 210                 }
 211
 212                 /*
 213                  * We use the object from the binding handle
 214                  */
 215                 object = h->object;
 216         }
 217
 218         subreq = state->ops->raw_call_send(state, ev, h,
 219                                            object, opnum,
 220                                            in_flags, in_data, in_length);
 221         if (tevent_req_nomem(subreq, req)) {
 222                 return tevent_req_post(req, ev);
 223         }
 224         tevent_req_set_callback(subreq, dcerpc_binding_handle_raw_call_done, req);
 225
 226         return req;
 227 }
 228
 229 static void dcerpc_binding_handle_raw_call_done(struct tevent_req *subreq)
 230 {
 231         struct tevent_req *req = tevent_req_callback_data(subreq,
 232                                  struct tevent_req);
 233         struct dcerpc_binding_handle_raw_call_state *state =
 234                 tevent_req_data(req,
 235                 struct dcerpc_binding_handle_raw_call_state);
 236         NTSTATUS error;
 237
 238         error = state->ops->raw_call_recv(subreq, state,
 239                                           &state->out_data,
 240                                           &state->out_length,
 241                                           &state->out_flags);
 242         TALLOC_FREE(subreq);
 243         if (tevent_req_nterror(req, error)) {
 244                 return;
 245         }
 246
 247         tevent_req_done(req);
 248 }
 249
 250 NTSTATUS dcerpc_binding_handle_raw_call_recv(struct tevent_req *req,
 251                                              TALLOC_CTX *mem_ctx,
 252                                              uint8_t **out_data,
 253                                              size_t *out_length,
 254                                              uint32_t *out_flags)
 255 {
 256         struct dcerpc_binding_handle_raw_call_state *state =
 257                 tevent_req_data(req,
 258                 struct dcerpc_binding_handle_raw_call_state);
 259         NTSTATUS error;
 260
 261         if (tevent_req_is_nterror(req, &error)) {
 262                 tevent_req_received(req);
 263                 return error;
 264         }
 265
 266         *out_data = talloc_move(mem_ctx, &state->out_data);
 267         *out_length = state->out_length;
 268         *out_flags = state->out_flags;
 269         tevent_req_received(req);
 270         return NT_STATUS_OK;
 271 }
 272
 273 NTSTATUS dcerpc_binding_handle_raw_call(struct dcerpc_binding_handle *h,
 274                                         const struct GUID *object,
 275                                         uint32_t opnum,
 276                                         uint32_t in_flags,
 277                                         const uint8_t *in_data,
 278                                         size_t in_length,
 279                                         TALLOC_CTX *mem_ctx,
 280                                         uint8_t **out_data,
 281                                         size_t *out_length,
 282                                         uint32_t *out_flags)
 283 {
 284         TALLOC_CTX *frame = talloc_stackframe();
 285         struct tevent_context *ev;
 286         struct tevent_req *subreq;
 287         NTSTATUS status = NT_STATUS_NO_MEMORY;
 288
 289         /*
 290          * TODO: allow only one sync call
 291          */
 292
 293         if (h->sync_ev) {
 294                 ev = h->sync_ev;
 295         } else {
 296                 ev = samba_tevent_context_init(frame);
 297         }
 298         if (ev == NULL) {
 299                 goto fail;
 300         }
 301
 302         subreq = dcerpc_binding_handle_raw_call_send(frame, ev,
 303                                                      h, object, opnum,
 304                                                      in_flags,
 305                                                      in_data,
 306                                                      in_length);
 307         if (subreq == NULL) {
 308                 goto fail;
 309         }
 310
 311         if (!tevent_req_poll_ntstatus(subreq, ev, &status)) {
 312                 goto fail;
 313         }
 314
 315         status = dcerpc_binding_handle_raw_call_recv(subreq,
 316                                                      mem_ctx,
 317                                                      out_data,
 318                                                      out_length,
 319                                                      out_flags);
 320 fail:
 321         TALLOC_FREE(frame);
 322         return status;
 323 }
 324
 325 struct dcerpc_binding_handle_disconnect_state {
 326         const struct dcerpc_binding_handle_ops *ops;
 327 };
 328
 329 static void dcerpc_binding_handle_disconnect_done(struct tevent_req *subreq);
 330
 331 struct tevent_req *dcerpc_binding_handle_disconnect_send(TALLOC_CTX *mem_ctx,
 332                                                 struct tevent_context *ev,
 333                                                 struct dcerpc_binding_handle *h)
 334 {
 335         struct tevent_req *req;
 336         struct dcerpc_binding_handle_disconnect_state *state;
 337         struct tevent_req *subreq;
 338
 339         req = tevent_req_create(mem_ctx, &state,
 340                                 struct dcerpc_binding_handle_disconnect_state);
 341         if (req == NULL) {
 342                 return NULL;
 343         }
 344
 345         state->ops = h->ops;
 346
 347         subreq = state->ops->disconnect_send(state, ev, h);
 348         if (tevent_req_nomem(subreq, req)) {
 349                 return tevent_req_post(req, ev);
 350         }
 351         tevent_req_set_callback(subreq, dcerpc_binding_handle_disconnect_done, req);
 352
 353         return req;
 354 }
 355
 356 static void dcerpc_binding_handle_disconnect_done(struct tevent_req *subreq)
 357 {
 358         struct tevent_req *req = tevent_req_callback_data(subreq,
 359                                  struct tevent_req);
 360         struct dcerpc_binding_handle_disconnect_state *state =
 361                 tevent_req_data(req,
 362                 struct dcerpc_binding_handle_disconnect_state);
 363         NTSTATUS error;
 364
 365         error = state->ops->disconnect_recv(subreq);
 366         TALLOC_FREE(subreq);
 367         if (tevent_req_nterror(req, error)) {
 368                 return;
 369         }
 370
 371         tevent_req_done(req);
 372 }
 373
 374 NTSTATUS dcerpc_binding_handle_disconnect_recv(struct tevent_req *req)
 375 {
 376         NTSTATUS error;
 377
 378         if (tevent_req_is_nterror(req, &error)) {
 379                 tevent_req_received(req);
 380                 return error;
 381         }
 382
 383         tevent_req_received(req);
 384         return NT_STATUS_OK;
 385 }
 386
 387 struct dcerpc_binding_handle_call_state {
 388         struct dcerpc_binding_handle *h;
 389         const struct ndr_interface_call *call;
 390         TALLOC_CTX *r_mem;
 391         void *r_ptr;
 392         struct ndr_push *push;
 393         DATA_BLOB request;
 394         DATA_BLOB response;
 395         struct ndr_pull *pull;
 396 };
 397
 398 static void dcerpc_binding_handle_call_done(struct tevent_req *subreq);
 399
 400 struct tevent_req *dcerpc_binding_handle_call_send(TALLOC_CTX *mem_ctx,
 401                                         struct tevent_context *ev,
 402                                         struct dcerpc_binding_handle *h,
 403                                         const struct GUID *object,
 404                                         const struct ndr_interface_table *table,
 405                                         uint32_t opnum,
 406                                         TALLOC_CTX *r_mem,
 407                                         void *r_ptr)
 408 {
 409         struct tevent_req *req;
 410         struct dcerpc_binding_handle_call_state *state;
 411         struct tevent_req *subreq;
 412         enum ndr_err_code ndr_err;
 413
 414         req = tevent_req_create(mem_ctx, &state,
 415                                 struct dcerpc_binding_handle_call_state);
 416         if (req == NULL) {
 417                 return NULL;
 418         }
 419
 420         if (table != h->table) {
 421                 tevent_req_nterror(req, NT_STATUS_INVALID_HANDLE);
 422                 return tevent_req_post(req, ev);
 423         }
 424
 425         if (opnum >= table->num_calls) {
 426                 tevent_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
 427                 return tevent_req_post(req, ev);
 428         }
 429
 430         state->h = h;
 431         state->call = &table->calls[opnum];
 432
 433         state->r_mem = r_mem;
 434         state->r_ptr = r_ptr;
 435
 436         /* setup for a ndr_push_* call */
 437         state->push = ndr_push_init_ctx(state);
 438         if (tevent_req_nomem(state->push, req)) {
 439                 return tevent_req_post(req, ev);
 440         }
 441
 442         if (h->ops->ref_alloc && h->ops->ref_alloc(h)) {
 443                 state->push->flags |= LIBNDR_FLAG_REF_ALLOC;
 444         }
 445
 446         if (h->ops->push_bigendian && h->ops->push_bigendian(h)) {
 447                 state->push->flags |= LIBNDR_FLAG_BIGENDIAN;
 448         }
 449
 450         if (h->ops->use_ndr64 && h->ops->use_ndr64(h)) {
 451                 state->push->flags |= LIBNDR_FLAG_NDR64;
 452         }
 453
 454         if (h->ops->do_ndr_print) {
 455                 h->ops->do_ndr_print(h, NDR_IN | NDR_SET_VALUES,
 456                                      state->r_ptr, state->call);
 457         }
 458
 459         /* push the structure into a blob */
 460         ndr_err = state->call->ndr_push(state->push, NDR_IN, state->r_ptr);
 461         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 462                 NTSTATUS error;
 463                 error = ndr_map_error2ntstatus(ndr_err);
 464                 if (h->ops->ndr_push_failed) {
 465                         h->ops->ndr_push_failed(h, error,
 466                                                 state->r_ptr,
 467                                                 state->call);
 468                 }
 469                 tevent_req_nterror(req, error);
 470                 return tevent_req_post(req, ev);
 471         }
 472
 473         /* retrieve the blob */
 474         state->request = ndr_push_blob(state->push);
 475
 476         if (h->ops->ndr_validate_in) {
 477                 NTSTATUS error;
 478                 error = h->ops->ndr_validate_in(h, state,
 479                                                 &state->request,
 480                                                 state->call);
 481                 if (!NT_STATUS_IS_OK(error)) {
 482                         tevent_req_nterror(req, error);
 483                         return tevent_req_post(req, ev);
 484                 }
 485         }
 486
 487         subreq = dcerpc_binding_handle_raw_call_send(state, ev,
 488                                                      h, object, opnum,
 489                                                      state->push->flags,
 490                                                      state->request.data,
 491                                                      state->request.length);
 492         if (tevent_req_nomem(subreq, req)) {
 493                 return tevent_req_post(req, ev);
 494         }
 495         tevent_req_set_callback(subreq, dcerpc_binding_handle_call_done, req);
 496
 497         return req;
 498 }
 499
 500 static void dcerpc_binding_handle_call_done(struct tevent_req *subreq)
 501 {
 502         struct tevent_req *req = tevent_req_callback_data(subreq,
 503                                  struct tevent_req);
 504         struct dcerpc_binding_handle_call_state *state =
 505                 tevent_req_data(req,
 506                 struct dcerpc_binding_handle_call_state);
 507         struct dcerpc_binding_handle *h = state->h;
 508         NTSTATUS error;
 509         uint32_t out_flags = 0;
 510         enum ndr_err_code ndr_err;
 511
 512         error = dcerpc_binding_handle_raw_call_recv(subreq, state,
 513                                                     &state->response.data,
 514                                                     &state->response.length,
 515                                                     &out_flags);
 516         TALLOC_FREE(subreq);
 517         if (tevent_req_nterror(req, error)) {
 518                 return;
 519         }
 520
 521         state->pull = ndr_pull_init_blob(&state->response, state);
 522         if (tevent_req_nomem(state->pull, req)) {
 523                 return;
 524         }
 525         state->pull->flags = state->push->flags;
 526
 527         if (out_flags & LIBNDR_FLAG_BIGENDIAN) {
 528                 state->pull->flags |= LIBNDR_FLAG_BIGENDIAN;
 529         } else {
 530                 state->pull->flags &= ~LIBNDR_FLAG_BIGENDIAN;
 531         }
 532
 533         state->pull->current_mem_ctx = state->r_mem;
 534
 535         /* pull the structure from the blob */
 536         ndr_err = state->call->ndr_pull(state->pull, NDR_OUT, state->r_ptr);
 537         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 538                 error = ndr_map_error2ntstatus(ndr_err);
 539                 if (h->ops->ndr_pull_failed) {
 540                         h->ops->ndr_pull_failed(h, error,
 541                                                 &state->response,
 542                                                 state->call);
 543                 }
 544                 tevent_req_nterror(req, error);
 545                 return;
 546         }
 547
 548         if (h->ops->do_ndr_print) {
 549                 h->ops->do_ndr_print(h, NDR_OUT,
 550                                      state->r_ptr, state->call);
 551         }
 552
 553         if (h->ops->ndr_validate_out) {
 554                 error = h->ops->ndr_validate_out(h,
 555                                                  state->pull,
 556                                                  state->r_ptr,
 557                                                  state->call);
 558                 if (!NT_STATUS_IS_OK(error)) {
 559                         tevent_req_nterror(req, error);
 560                         return;
 561                 }
 562         }
 563
 564         tevent_req_done(req);
 565 }
 566
 567 NTSTATUS dcerpc_binding_handle_call_recv(struct tevent_req *req)
 568 {
 569         return tevent_req_simple_recv_ntstatus(req);
 570 }
 571
 572 NTSTATUS dcerpc_binding_handle_call(struct dcerpc_binding_handle *h,
 573                                     const struct GUID *object,
 574                                     const struct ndr_interface_table *table,
 575                                     uint32_t opnum,
 576                                     TALLOC_CTX *r_mem,
 577                                     void *r_ptr)
 578 {
 579         TALLOC_CTX *frame = talloc_stackframe();
 580         struct tevent_context *ev;
 581         struct tevent_req *subreq;
 582         NTSTATUS status = NT_STATUS_NO_MEMORY;
 583
 584         /*
 585          * TODO: allow only one sync call
 586          */
 587
 588         if (h->sync_ev) {
 589                 ev = h->sync_ev;
 590         } else {
 591                 ev = samba_tevent_context_init(frame);
 592         }
 593         if (ev == NULL) {
 594                 goto fail;
 595         }
 596
 597         subreq = dcerpc_binding_handle_call_send(frame, ev,
 598                                                  h, object, table,
 599                                                  opnum, r_mem, r_ptr);
 600         if (subreq == NULL) {
 601                 goto fail;
 602         }
 603
 604         if (!tevent_req_poll_ntstatus(subreq, ev, &status)) {
 605                 goto fail;
 606         }
 607
 608         status = dcerpc_binding_handle_call_recv(subreq);
 609 fail:
 610         TALLOC_FREE(frame);
 611         return status;
 612 }