source4/librpc/rpc/dcerpc_connect.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    dcerpc connect functions
   5
   6    Copyright (C) Andrew Tridgell 2003
   7    Copyright (C) Jelmer Vernooij 2004
   8    Copyright (C) Andrew Bartlett <abartlet@samba.org> 2005-2007
   9    Copyright (C) Rafal Szczesniak  2005
  10
  11    This program is free software; you can redistribute it and/or modify
  12    it under the terms of the GNU General Public License as published by
  13    the Free Software Foundation; either version 3 of the License, or
  14    (at your option) any later version.
  15
  16    This program is distributed in the hope that it will be useful,
  17    but WITHOUT ANY WARRANTY; without even the implied warranty of
  18    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19    GNU General Public License for more details.
  20
  21    You should have received a copy of the GNU General Public License
  22    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  23 */
  24
  25
  26 #include "includes.h"
  27 #include "libcli/composite/composite.h"
  28 #include "libcli/smb_composite/smb_composite.h"
  29 #include "lib/events/events.h"
  30 #include "libcli/smb2/smb2.h"
  31 #include "libcli/smb2/smb2_calls.h"
  32 #include "libcli/smb/smbXcli_base.h"
  33 #include "librpc/rpc/dcerpc.h"
  34 #include "librpc/rpc/dcerpc_proto.h"
  35 #include "auth/credentials/credentials.h"
  36 #include "param/param.h"
  37 #include "libcli/resolve/resolve.h"
  38
  39 struct dcerpc_pipe_connect {
  40         struct dcerpc_pipe *pipe;
  41         struct dcerpc_binding *binding;
  42         const char *pipe_name;
  43         const struct ndr_interface_table *interface;
  44         struct cli_credentials *creds;
  45         struct resolve_context *resolve_ctx;
  46 };
  47
  48 struct pipe_np_smb_state {
  49         struct smb_composite_connect conn;
  50         struct dcerpc_pipe_connect io;
  51 };
  52
  53
  54 /*
  55   Stage 3 of ncacn_np_smb: Named pipe opened (or not)
  56 */
  57 static void continue_pipe_open_smb(struct composite_context *ctx)
  58 {
  59         struct composite_context *c = talloc_get_type(ctx->async.private_data,
  60                                                       struct composite_context);
  61
  62         /* receive result of named pipe open request on smb */
  63         c->status = dcerpc_pipe_open_smb_recv(ctx);
  64         if (!composite_is_ok(c)) return;
  65
  66         composite_done(c);
  67 }
  68
  69
  70 /*
  71   Stage 2 of ncacn_np_smb: Open a named pipe after successful smb connection
  72 */
  73 static void continue_smb_connect(struct composite_context *ctx)
  74 {
  75         struct composite_context *open_ctx;
  76         struct composite_context *c = talloc_get_type(ctx->async.private_data,
  77                                                       struct composite_context);
  78         struct pipe_np_smb_state *s = talloc_get_type(c->private_data,
  79                                                       struct pipe_np_smb_state);
  80         struct smbcli_tree *t;
  81         struct smbXcli_conn *conn;
  82         struct smbXcli_session *session;
  83         struct smbXcli_tcon *tcon;
  84         uint32_t timeout_msec;
  85
  86         /* receive result of smb connect request */
  87         c->status = smb_composite_connect_recv(ctx, s->io.pipe->conn);
  88         if (!composite_is_ok(c)) return;
  89
  90         /* prepare named pipe open parameters */
  91         s->io.pipe_name = s->io.binding->endpoint;
  92
  93         t = s->conn.out.tree;
  94         conn = t->session->transport->conn;
  95         session = t->session->smbXcli;
  96         tcon = t->smbXcli;
  97         smb1cli_tcon_set_id(tcon, t->tid);
  98         timeout_msec = t->session->transport->options.request_timeout * 1000;
  99
 100         /* if we don't have a binding on this pipe yet, then create one */
 101         if (s->io.pipe->binding == NULL) {
 102                 const char *r = smbXcli_conn_remote_name(conn);
 103                 char *str;
 104                 SMB_ASSERT(r != NULL);
 105                 str = talloc_asprintf(s, "ncacn_np:%s", r);
 106                 if (composite_nomem(str, c)) return;
 107                 c->status = dcerpc_parse_binding(s->io.pipe, str,
 108                                                  &s->io.pipe->binding);
 109                 talloc_free(str);
 110                 if (!composite_is_ok(c)) return;
 111         }
 112
 113         /* send named pipe open request */
 114         open_ctx = dcerpc_pipe_open_smb_send(s->io.pipe->conn,
 115                                              conn, session,
 116                                              tcon, timeout_msec,
 117                                              s->io.pipe_name);
 118         if (composite_nomem(open_ctx, c)) return;
 119
 120         composite_continue(c, open_ctx, continue_pipe_open_smb, c);
 121 }
 122
 123
 124 /*
 125   Initiate async open of a rpc connection to a rpc pipe on SMB using
 126   the binding structure to determine the endpoint and options
 127 */
 128 static struct composite_context *dcerpc_pipe_connect_ncacn_np_smb_send(TALLOC_CTX *mem_ctx, struct dcerpc_pipe_connect *io, struct loadparm_context *lp_ctx)
 129 {
 130         struct composite_context *c;
 131         struct pipe_np_smb_state *s;
 132         struct composite_context *conn_req;
 133         struct smb_composite_connect *conn;
 134
 135         /* composite context allocation and setup */
 136         c = composite_create(mem_ctx, io->pipe->conn->event_ctx);
 137         if (c == NULL) return NULL;
 138
 139         s = talloc_zero(c, struct pipe_np_smb_state);
 140         if (composite_nomem(s, c)) return c;
 141         c->private_data = s;
 142
 143         s->io  = *io;
 144         conn   = &s->conn;
 145
 146         /* prepare smb connection parameters: we're connecting to IPC$ share on
 147            remote rpc server */
 148         conn->in.dest_host              = s->io.binding->host;
 149         conn->in.dest_ports                  = lpcfg_smb_ports(lp_ctx);
 150         if (s->io.binding->target_hostname == NULL)
 151                 conn->in.called_name = "*SMBSERVER"; /* FIXME: This is invalid */
 152         else
 153                 conn->in.called_name            = s->io.binding->target_hostname;
 154         conn->in.socket_options         = lpcfg_socket_options(lp_ctx);
 155         conn->in.service                = "IPC$";
 156         conn->in.service_type           = NULL;
 157         conn->in.workgroup              = lpcfg_workgroup(lp_ctx);
 158         conn->in.gensec_settings = lpcfg_gensec_settings(conn, lp_ctx);
 159
 160         lpcfg_smbcli_options(lp_ctx, &conn->in.options);
 161         lpcfg_smbcli_session_options(lp_ctx, &conn->in.session_options);
 162
 163         /*
 164          * provide proper credentials - user supplied, but allow a
 165          * fallback to anonymous if this is an schannel connection
 166          * (might be NT4 not allowing machine logins at session
 167          * setup) or if asked to do so by the caller (perhaps a SAMR password change?)
 168          */
 169         s->conn.in.credentials = s->io.creds;
 170         if (s->io.binding->flags & (DCERPC_SCHANNEL|DCERPC_ANON_FALLBACK)) {
 171                 conn->in.fallback_to_anonymous  = true;
 172         } else {
 173                 conn->in.fallback_to_anonymous  = false;
 174         }
 175
 176         /* send smb connect request */
 177         conn_req = smb_composite_connect_send(conn, s->io.pipe->conn,
 178                                               s->io.resolve_ctx,
 179                                               s->io.pipe->conn->event_ctx);
 180         if (composite_nomem(conn_req, c)) return c;
 181
 182         composite_continue(c, conn_req, continue_smb_connect, c);
 183         return c;
 184 }
 185
 186
 187 /*
 188   Receive result of a rpc connection to a rpc pipe on SMB
 189 */
 190 static NTSTATUS dcerpc_pipe_connect_ncacn_np_smb_recv(struct composite_context *c)
 191 {
 192         NTSTATUS status = composite_wait(c);
 193
 194         talloc_free(c);
 195         return status;
 196 }
 197
 198
 199 struct pipe_np_smb2_state {
 200         struct dcerpc_pipe_connect io;
 201 };
 202
 203
 204 /*
 205   Stage 3 of ncacn_np_smb: Named pipe opened (or not)
 206 */
 207 static void continue_pipe_open_smb2(struct composite_context *ctx)
 208 {
 209         struct composite_context *c = talloc_get_type(ctx->async.private_data,
 210                                                       struct composite_context);
 211
 212         /* receive result of named pipe open request on smb2 */
 213         c->status = dcerpc_pipe_open_smb_recv(ctx);
 214         if (!composite_is_ok(c)) return;
 215
 216         composite_done(c);
 217 }
 218
 219
 220 /*
 221   Stage 2 of ncacn_np_smb2: Open a named pipe after successful smb2 connection
 222 */
 223 static void continue_smb2_connect(struct tevent_req *subreq)
 224 {
 225         struct composite_context *open_req;
 226         struct composite_context *c =
 227                 tevent_req_callback_data(subreq,
 228                 struct composite_context);
 229         struct pipe_np_smb2_state *s = talloc_get_type(c->private_data,
 230                                                        struct pipe_np_smb2_state);
 231         struct smb2_tree *t;
 232         struct smbXcli_conn *conn;
 233         struct smbXcli_session *session;
 234         struct smbXcli_tcon *tcon;
 235         uint32_t timeout_msec;
 236
 237         /* receive result of smb2 connect request */
 238         c->status = smb2_connect_recv(subreq, s->io.pipe->conn, &t);
 239         TALLOC_FREE(subreq);
 240         if (!composite_is_ok(c)) return;
 241
 242         /* prepare named pipe open parameters */
 243         s->io.pipe_name = s->io.binding->endpoint;
 244
 245         conn = t->session->transport->conn;
 246         session = t->session->smbXcli;
 247         tcon = t->smbXcli;
 248         timeout_msec = t->session->transport->options.request_timeout * 1000;
 249
 250         /* if we don't have a binding on this pipe yet, then create one */
 251         if (s->io.pipe->binding == NULL) {
 252                 const char *r = smbXcli_conn_remote_name(conn);
 253                 char *str;
 254                 SMB_ASSERT(r != NULL);
 255                 str = talloc_asprintf(s, "ncacn_np:%s", r);
 256                 if (composite_nomem(str, c)) return;
 257                 c->status = dcerpc_parse_binding(s->io.pipe, str,
 258                                                  &s->io.pipe->binding);
 259                 talloc_free(str);
 260                 if (!composite_is_ok(c)) return;
 261         }
 262
 263         /* send named pipe open request */
 264         open_req = dcerpc_pipe_open_smb_send(s->io.pipe->conn,
 265                                              conn, session,
 266                                              tcon, timeout_msec,
 267                                              s->io.pipe_name);
 268         if (composite_nomem(open_req, c)) return;
 269
 270         composite_continue(c, open_req, continue_pipe_open_smb2, c);
 271 }
 272
 273
 274 /*
 275    Initiate async open of a rpc connection request on SMB2 using
 276    the binding structure to determine the endpoint and options
 277 */
 278 static struct composite_context *dcerpc_pipe_connect_ncacn_np_smb2_send(
 279                                         TALLOC_CTX *mem_ctx,
 280                                         struct dcerpc_pipe_connect *io,
 281                                         struct loadparm_context *lp_ctx)
 282 {
 283         struct composite_context *c;
 284         struct pipe_np_smb2_state *s;
 285         struct tevent_req *subreq;
 286         struct smbcli_options options;
 287
 288         /* composite context allocation and setup */
 289         c = composite_create(mem_ctx, io->pipe->conn->event_ctx);
 290         if (c == NULL) return NULL;
 291
 292         s = talloc_zero(c, struct pipe_np_smb2_state);
 293         if (composite_nomem(s, c)) return c;
 294         c->private_data = s;
 295
 296         s->io = *io;
 297
 298         /*
 299          * provide proper credentials - user supplied or anonymous in case this is
 300          * schannel connection
 301          */
 302         if (s->io.binding->flags & DCERPC_SCHANNEL) {
 303                 s->io.creds = cli_credentials_init(mem_ctx);
 304                 if (composite_nomem(s->io.creds, c)) return c;
 305
 306                 cli_credentials_guess(s->io.creds, lp_ctx);
 307         }
 308
 309         lpcfg_smbcli_options(lp_ctx, &options);
 310
 311         /* send smb2 connect request */
 312         subreq = smb2_connect_send(s, c->event_ctx,
 313                         s->io.binding->host,
 314                         lpcfg_parm_string_list(mem_ctx, lp_ctx, NULL, "smb2", "ports", NULL),
 315                         "IPC$",
 316                         s->io.resolve_ctx,
 317                         s->io.creds,
 318                         0, /* previous_session_id */
 319                         &options,
 320                         lpcfg_socket_options(lp_ctx),
 321                         lpcfg_gensec_settings(mem_ctx, lp_ctx));
 322         if (composite_nomem(subreq, c)) return c;
 323         tevent_req_set_callback(subreq, continue_smb2_connect, c);
 324         return c;
 325 }
 326
 327
 328 /*
 329   Receive result of a rpc connection to a rpc pipe on SMB2
 330 */
 331 static NTSTATUS dcerpc_pipe_connect_ncacn_np_smb2_recv(struct composite_context *c)
 332 {
 333         NTSTATUS status = composite_wait(c);
 334
 335         talloc_free(c);
 336         return status;
 337 }
 338
 339
 340 struct pipe_ip_tcp_state {
 341         struct dcerpc_pipe_connect io;
 342         const char *localaddr;
 343         const char *host;
 344         const char *target_hostname;
 345         uint32_t port;
 346 };
 347
 348
 349 /*
 350   Stage 2 of ncacn_ip_tcp: rpc pipe opened (or not)
 351 */
 352 static void continue_pipe_open_ncacn_ip_tcp(struct composite_context *ctx)
 353 {
 354         struct composite_context *c = talloc_get_type(ctx->async.private_data,
 355                                                       struct composite_context);
 356
 357         /* receive result of named pipe open request on tcp/ip */
 358         c->status = dcerpc_pipe_open_tcp_recv(ctx);
 359         if (!composite_is_ok(c)) return;
 360
 361         composite_done(c);
 362 }
 363
 364
 365 /*
 366   Initiate async open of a rpc connection to a rpc pipe on TCP/IP using
 367   the binding structure to determine the endpoint and options
 368 */
 369 static struct composite_context* dcerpc_pipe_connect_ncacn_ip_tcp_send(TALLOC_CTX *mem_ctx,
 370                                                                        struct dcerpc_pipe_connect *io)
 371 {
 372         struct composite_context *c;
 373         struct pipe_ip_tcp_state *s;
 374         struct composite_context *pipe_req;
 375
 376         /* composite context allocation and setup */
 377         c = composite_create(mem_ctx, io->pipe->conn->event_ctx);
 378         if (c == NULL) return NULL;
 379
 380         s = talloc_zero(c, struct pipe_ip_tcp_state);
 381         if (composite_nomem(s, c)) return c;
 382         c->private_data = s;
 383
 384         /* store input parameters in state structure */
 385         s->io               = *io;
 386         s->localaddr = dcerpc_binding_get_string_option(io->binding,
 387                                                         "localaddress");
 388         if (io->binding->host != NULL) {
 389                 s->host = talloc_strdup(s, io->binding->host);
 390                 if (composite_nomem(s->host, c)) return c;
 391         }
 392         if (io->binding->target_hostname != NULL) {
 393                 s->target_hostname = talloc_strdup(s, io->binding->target_hostname);
 394                 if (composite_nomem(s->target_hostname, c)) return c;
 395         }
 396                              /* port number is a binding endpoint here */
 397         s->port             = atoi(io->binding->endpoint);
 398
 399         /* send pipe open request on tcp/ip */
 400         pipe_req = dcerpc_pipe_open_tcp_send(s->io.pipe->conn, s->localaddr, s->host, s->target_hostname,
 401                                              s->port, io->resolve_ctx);
 402         composite_continue(c, pipe_req, continue_pipe_open_ncacn_ip_tcp, c);
 403         return c;
 404 }
 405
 406
 407 /*
 408   Receive result of a rpc connection to a rpc pipe on TCP/IP
 409 */
 410 static NTSTATUS dcerpc_pipe_connect_ncacn_ip_tcp_recv(struct composite_context *c)
 411 {
 412         NTSTATUS status = composite_wait(c);
 413
 414         talloc_free(c);
 415         return status;
 416 }
 417
 418
 419 struct pipe_unix_state {
 420         struct dcerpc_pipe_connect io;
 421         const char *path;
 422 };
 423
 424
 425 /*
 426   Stage 2 of ncacn_unix: rpc pipe opened (or not)
 427 */
 428 static void continue_pipe_open_ncacn_unix_stream(struct composite_context *ctx)
 429 {
 430         struct composite_context *c = talloc_get_type(ctx->async.private_data,
 431                                                       struct composite_context);
 432
 433         /* receive result of pipe open request on unix socket */
 434         c->status = dcerpc_pipe_open_unix_stream_recv(ctx);
 435         if (!composite_is_ok(c)) return;
 436
 437         composite_done(c);
 438 }
 439
 440
 441 /*
 442   Initiate async open of a rpc connection to a rpc pipe on unix socket using
 443   the binding structure to determine the endpoint and options
 444 */
 445 static struct composite_context* dcerpc_pipe_connect_ncacn_unix_stream_send(TALLOC_CTX *mem_ctx,
 446                                                                             struct dcerpc_pipe_connect *io)
 447 {
 448         struct composite_context *c;
 449         struct pipe_unix_state *s;
 450         struct composite_context *pipe_req;
 451
 452         /* composite context allocation and setup */
 453         c = composite_create(mem_ctx, io->pipe->conn->event_ctx);
 454         if (c == NULL) return NULL;
 455
 456         s = talloc_zero(c, struct pipe_unix_state);
 457         if (composite_nomem(s, c)) return c;
 458         c->private_data = s;
 459
 460         /* prepare pipe open parameters and store them in state structure
 461            also, verify whether biding endpoint is not null */
 462         s->io = *io;
 463
 464         if (!io->binding->endpoint) {
 465                 DEBUG(0, ("Path to unix socket not specified\n"));
 466                 composite_error(c, NT_STATUS_INVALID_PARAMETER);
 467                 return c;
 468         }
 469
 470         s->path  = talloc_strdup(c, io->binding->endpoint);  /* path is a binding endpoint here */
 471         if (composite_nomem(s->path, c)) return c;
 472
 473         /* send pipe open request on unix socket */
 474         pipe_req = dcerpc_pipe_open_unix_stream_send(s->io.pipe->conn, s->path);
 475         composite_continue(c, pipe_req, continue_pipe_open_ncacn_unix_stream, c);
 476         return c;
 477 }
 478
 479
 480 /*
 481   Receive result of a rpc connection to a pipe on unix socket
 482 */
 483 static NTSTATUS dcerpc_pipe_connect_ncacn_unix_stream_recv(struct composite_context *c)
 484 {
 485         NTSTATUS status = composite_wait(c);
 486
 487         talloc_free(c);
 488         return status;
 489 }
 490
 491
 492 struct pipe_ncalrpc_state {
 493         struct dcerpc_pipe_connect io;
 494 };
 495
 496 static NTSTATUS dcerpc_pipe_connect_ncalrpc_recv(struct composite_context *c);
 497
 498 /*
 499   Stage 2 of ncalrpc: rpc pipe opened (or not)
 500 */
 501 static void continue_pipe_open_ncalrpc(struct composite_context *ctx)
 502 {
 503         struct composite_context *c = talloc_get_type(ctx->async.private_data,
 504                                                       struct composite_context);
 505
 506         /* receive result of pipe open request on ncalrpc */
 507         c->status = dcerpc_pipe_connect_ncalrpc_recv(ctx);
 508         if (!composite_is_ok(c)) return;
 509
 510         composite_done(c);
 511 }
 512
 513
 514 /*
 515    Initiate async open of a rpc connection request on NCALRPC using
 516    the binding structure to determine the endpoint and options
 517 */
 518 static struct composite_context* dcerpc_pipe_connect_ncalrpc_send(TALLOC_CTX *mem_ctx,
 519                                                                   struct dcerpc_pipe_connect *io, struct loadparm_context *lp_ctx)
 520 {
 521         struct composite_context *c;
 522         struct pipe_ncalrpc_state *s;
 523         struct composite_context *pipe_req;
 524
 525         /* composite context allocation and setup */
 526         c = composite_create(mem_ctx, io->pipe->conn->event_ctx);
 527         if (c == NULL) return NULL;
 528
 529         s = talloc_zero(c, struct pipe_ncalrpc_state);
 530         if (composite_nomem(s, c)) return c;
 531         c->private_data = s;
 532
 533         /* store input parameters in state structure */
 534         s->io  = *io;
 535
 536         /* send pipe open request */
 537         pipe_req = dcerpc_pipe_open_pipe_send(s->io.pipe->conn, lpcfg_ncalrpc_dir(lp_ctx),
 538                                               s->io.binding->endpoint);
 539         composite_continue(c, pipe_req, continue_pipe_open_ncalrpc, c);
 540         return c;
 541 }
 542
 543
 544 /*
 545   Receive result of a rpc connection to a rpc pipe on NCALRPC
 546 */
 547 static NTSTATUS dcerpc_pipe_connect_ncalrpc_recv(struct composite_context *c)
 548 {
 549         NTSTATUS status = composite_wait(c);
 550
 551         talloc_free(c);
 552         return status;
 553 }
 554
 555
 556 struct pipe_connect_state {
 557         struct dcerpc_pipe *pipe;
 558         struct dcerpc_binding *binding;
 559         const struct ndr_interface_table *table;
 560         struct cli_credentials *credentials;
 561         struct loadparm_context *lp_ctx;
 562 };
 563
 564
 565 static void continue_map_binding(struct composite_context *ctx);
 566 static void continue_connect(struct composite_context *c, struct pipe_connect_state *s);
 567 static void continue_pipe_connect_ncacn_np_smb2(struct composite_context *ctx);
 568 static void continue_pipe_connect_ncacn_np_smb(struct composite_context *ctx);
 569 static void continue_pipe_connect_ncacn_ip_tcp(struct composite_context *ctx);
 570 static void continue_pipe_connect_ncacn_unix(struct composite_context *ctx);
 571 static void continue_pipe_connect_ncalrpc(struct composite_context *ctx);
 572 static void continue_pipe_connect(struct composite_context *c, struct pipe_connect_state *s);
 573 static void continue_pipe_auth(struct composite_context *ctx);
 574
 575
 576 /*
 577   Stage 2 of pipe_connect_b: Receive result of endpoint mapping
 578 */
 579 static void continue_map_binding(struct composite_context *ctx)
 580 {
 581         struct composite_context *c = talloc_get_type(ctx->async.private_data,
 582                                                       struct composite_context);
 583         struct pipe_connect_state *s = talloc_get_type(c->private_data,
 584                                                        struct pipe_connect_state);
 585
 586         c->status = dcerpc_epm_map_binding_recv(ctx);
 587         if (!composite_is_ok(c)) return;
 588
 589         DEBUG(4,("Mapped to DCERPC endpoint %s\n", s->binding->endpoint));
 590
 591         continue_connect(c, s);
 592 }
 593
 594
 595 /*
 596   Stage 2 of pipe_connect_b: Continue connection after endpoint is known
 597 */
 598 static void continue_connect(struct composite_context *c, struct pipe_connect_state *s)
 599 {
 600         struct dcerpc_pipe_connect pc;
 601
 602         /* potential exits to another stage by sending an async request */
 603         struct composite_context *ncacn_np_smb2_req;
 604         struct composite_context *ncacn_np_smb_req;
 605         struct composite_context *ncacn_ip_tcp_req;
 606         struct composite_context *ncacn_unix_req;
 607         struct composite_context *ncalrpc_req;
 608         enum dcerpc_transport_t transport;
 609         uint32_t flags;
 610
 611         /* dcerpc pipe connect input parameters */
 612         pc.pipe         = s->pipe;
 613         pc.binding      = s->binding;
 614         pc.pipe_name    = NULL;
 615         pc.interface    = s->table;
 616         pc.creds        = s->credentials;
 617         pc.resolve_ctx  = lpcfg_resolve_context(s->lp_ctx);
 618
 619         transport = dcerpc_binding_get_transport(s->binding);
 620         flags = dcerpc_binding_get_flags(s->binding);
 621
 622         /* connect dcerpc pipe depending on required transport */
 623         switch (transport) {
 624         case NCACN_NP:
 625                 if (flags & DCERPC_SMB2) {
 626                         /* new varient of SMB a.k.a. SMB2 */
 627                         ncacn_np_smb2_req = dcerpc_pipe_connect_ncacn_np_smb2_send(c, &pc, s->lp_ctx);
 628                         composite_continue(c, ncacn_np_smb2_req, continue_pipe_connect_ncacn_np_smb2, c);
 629                         return;
 630
 631                 } else {
 632                         /* good old ordinary SMB */
 633                         ncacn_np_smb_req = dcerpc_pipe_connect_ncacn_np_smb_send(c, &pc, s->lp_ctx);
 634                         composite_continue(c, ncacn_np_smb_req, continue_pipe_connect_ncacn_np_smb, c);
 635                         return;
 636                 }
 637                 break;
 638
 639         case NCACN_IP_TCP:
 640                 ncacn_ip_tcp_req = dcerpc_pipe_connect_ncacn_ip_tcp_send(c, &pc);
 641                 composite_continue(c, ncacn_ip_tcp_req, continue_pipe_connect_ncacn_ip_tcp, c);
 642                 return;
 643
 644         case NCACN_UNIX_STREAM:
 645                 ncacn_unix_req = dcerpc_pipe_connect_ncacn_unix_stream_send(c, &pc);
 646                 composite_continue(c, ncacn_unix_req, continue_pipe_connect_ncacn_unix, c);
 647                 return;
 648
 649         case NCALRPC:
 650                 ncalrpc_req = dcerpc_pipe_connect_ncalrpc_send(c, &pc, s->lp_ctx);
 651                 composite_continue(c, ncalrpc_req, continue_pipe_connect_ncalrpc, c);
 652                 return;
 653
 654         default:
 655                 /* looks like a transport we don't support now */
 656                 composite_error(c, NT_STATUS_NOT_SUPPORTED);
 657         }
 658 }
 659
 660
 661 /*
 662   Stage 3 of pipe_connect_b: Receive result of pipe connect request on
 663   named pipe on smb2
 664 */
 665 static void continue_pipe_connect_ncacn_np_smb2(struct composite_context *ctx)
 666 {
 667         struct composite_context *c = talloc_get_type(ctx->async.private_data,
 668                                                       struct composite_context);
 669         struct pipe_connect_state *s = talloc_get_type(c->private_data,
 670                                                        struct pipe_connect_state);
 671
 672         c->status = dcerpc_pipe_connect_ncacn_np_smb2_recv(ctx);
 673         if (!composite_is_ok(c)) return;
 674
 675         continue_pipe_connect(c, s);
 676 }
 677
 678
 679 /*
 680   Stage 3 of pipe_connect_b: Receive result of pipe connect request on
 681   named pipe on smb
 682 */
 683 static void continue_pipe_connect_ncacn_np_smb(struct composite_context *ctx)
 684 {
 685         struct composite_context *c = talloc_get_type(ctx->async.private_data,
 686                                                       struct composite_context);
 687         struct pipe_connect_state *s = talloc_get_type(c->private_data,
 688                                                        struct pipe_connect_state);
 689
 690         c->status = dcerpc_pipe_connect_ncacn_np_smb_recv(ctx);
 691         if (!composite_is_ok(c)) return;
 692
 693         continue_pipe_connect(c, s);
 694 }
 695
 696
 697 /*
 698   Stage 3 of pipe_connect_b: Receive result of pipe connect request on tcp/ip
 699 */
 700 static void continue_pipe_connect_ncacn_ip_tcp(struct composite_context *ctx)
 701 {
 702         struct composite_context *c = talloc_get_type(ctx->async.private_data,
 703                                                       struct composite_context);
 704         struct pipe_connect_state *s = talloc_get_type(c->private_data,
 705                                                        struct pipe_connect_state);
 706
 707         c->status = dcerpc_pipe_connect_ncacn_ip_tcp_recv(ctx);
 708         if (!composite_is_ok(c)) return;
 709
 710         continue_pipe_connect(c, s);
 711 }
 712
 713
 714 /*
 715   Stage 3 of pipe_connect_b: Receive result of pipe connect request on unix socket
 716 */
 717 static void continue_pipe_connect_ncacn_unix(struct composite_context *ctx)
 718 {
 719         struct composite_context *c = talloc_get_type(ctx->async.private_data,
 720                                                       struct composite_context);
 721         struct pipe_connect_state *s = talloc_get_type(c->private_data,
 722                                                        struct pipe_connect_state);
 723
 724         c->status = dcerpc_pipe_connect_ncacn_unix_stream_recv(ctx);
 725         if (!composite_is_ok(c)) return;
 726
 727         continue_pipe_connect(c, s);
 728 }
 729
 730
 731 /*
 732   Stage 3 of pipe_connect_b: Receive result of pipe connect request on local rpc
 733 */
 734 static void continue_pipe_connect_ncalrpc(struct composite_context *ctx)
 735 {
 736         struct composite_context *c = talloc_get_type(ctx->async.private_data,
 737                                                       struct composite_context);
 738         struct pipe_connect_state *s = talloc_get_type(c->private_data,
 739                                                        struct pipe_connect_state);
 740
 741         c->status = dcerpc_pipe_connect_ncalrpc_recv(ctx);
 742         if (!composite_is_ok(c)) return;
 743
 744         continue_pipe_connect(c, s);
 745 }
 746
 747
 748 /*
 749   Stage 4 of pipe_connect_b: Start an authentication on connected dcerpc pipe
 750   depending on credentials and binding flags passed.
 751 */
 752 static void continue_pipe_connect(struct composite_context *c, struct pipe_connect_state *s)
 753 {
 754         struct composite_context *auth_bind_req;
 755
 756         s->pipe->binding = dcerpc_binding_dup(s->pipe, s->binding);
 757         if (composite_nomem(s->pipe->binding, c)) {
 758                 return;
 759         }
 760
 761         auth_bind_req = dcerpc_pipe_auth_send(s->pipe, s->binding, s->table,
 762                                               s->credentials, s->lp_ctx);
 763         composite_continue(c, auth_bind_req, continue_pipe_auth, c);
 764 }
 765
 766
 767 /*
 768   Stage 5 of pipe_connect_b: Receive result of pipe authentication request
 769   and say if all went ok
 770 */
 771 static void continue_pipe_auth(struct composite_context *ctx)
 772 {
 773         struct composite_context *c = talloc_get_type(ctx->async.private_data,
 774                                                       struct composite_context);
 775         struct pipe_connect_state *s = talloc_get_type(c->private_data, struct pipe_connect_state);
 776
 777         c->status = dcerpc_pipe_auth_recv(ctx, s, &s->pipe);
 778         if (!composite_is_ok(c)) return;
 779
 780         composite_done(c);
 781 }
 782
 783
 784 /*
 785   handle timeouts of a dcerpc connect
 786 */
 787 static void dcerpc_connect_timeout_handler(struct tevent_context *ev, struct tevent_timer *te,
 788                                            struct timeval t, void *private_data)
 789 {
 790         struct composite_context *c = talloc_get_type_abort(private_data,
 791                                                       struct composite_context);
 792         struct pipe_connect_state *s = talloc_get_type_abort(c->private_data, struct pipe_connect_state);
 793         if (!s->pipe->inhibit_timeout_processing) {
 794                 composite_error(c, NT_STATUS_IO_TIMEOUT);
 795         } else {
 796                 s->pipe->timed_out = true;
 797         }
 798 }
 799
 800 /*
 801   start a request to open a rpc connection to a rpc pipe, using
 802   specified binding structure to determine the endpoint and options
 803 */
 804 _PUBLIC_ struct composite_context* dcerpc_pipe_connect_b_send(TALLOC_CTX *parent_ctx,
 805                                                      const struct dcerpc_binding *binding,
 806                                                      const struct ndr_interface_table *table,
 807                                                      struct cli_credentials *credentials,
 808                                                      struct tevent_context *ev,
 809                                                      struct loadparm_context *lp_ctx)
 810 {
 811         struct composite_context *c;
 812         struct pipe_connect_state *s;
 813         enum dcerpc_transport_t transport;
 814         const char *endpoint = NULL;
 815
 816         /* composite context allocation and setup */
 817         c = composite_create(parent_ctx, ev);
 818         if (c == NULL) {
 819                 return NULL;
 820         }
 821
 822         s = talloc_zero(c, struct pipe_connect_state);
 823         if (composite_nomem(s, c)) return c;
 824         c->private_data = s;
 825
 826         /* initialise dcerpc pipe structure */
 827         s->pipe = dcerpc_pipe_init(c, ev);
 828         if (composite_nomem(s->pipe, c)) return c;
 829
 830         if (DEBUGLEVEL >= 10)
 831                 s->pipe->conn->packet_log_dir = lpcfg_lock_directory(lp_ctx);
 832
 833         /* store parameters in state structure */
 834         s->binding      = dcerpc_binding_dup(s, binding);
 835         if (composite_nomem(s->binding, c)) return c;
 836         s->table        = table;
 837         s->credentials  = credentials;
 838         s->lp_ctx       = lp_ctx;
 839
 840         s->pipe->timed_out = false;
 841         s->pipe->inhibit_timeout_processing = false;
 842
 843         tevent_add_timer(c->event_ctx, c,
 844                          timeval_current_ofs(DCERPC_REQUEST_TIMEOUT, 0),
 845                          dcerpc_connect_timeout_handler, c);
 846
 847         transport = dcerpc_binding_get_transport(s->binding);
 848
 849         switch (transport) {
 850         case NCACN_NP:
 851         case NCACN_IP_TCP:
 852         case NCALRPC:
 853                 endpoint = dcerpc_binding_get_string_option(s->binding, "endpoint");
 854                 break;
 855         default:
 856                 break;
 857         }
 858
 859         if (endpoint == NULL) {
 860                 struct composite_context *binding_req;
 861
 862                 binding_req = dcerpc_epm_map_binding_send(c, s->binding, s->table,
 863                                                           s->pipe->conn->event_ctx,
 864                                                           s->lp_ctx);
 865                 composite_continue(c, binding_req, continue_map_binding, c);
 866                 return c;
 867         }
 868
 869         continue_connect(c, s);
 870         return c;
 871 }
 872
 873
 874 /*
 875   receive result of a request to open a rpc connection to a rpc pipe
 876 */
 877 _PUBLIC_ NTSTATUS dcerpc_pipe_connect_b_recv(struct composite_context *c, TALLOC_CTX *mem_ctx,
 878                                     struct dcerpc_pipe **p)
 879 {
 880         NTSTATUS status;
 881         struct pipe_connect_state *s;
 882
 883         status = composite_wait(c);
 884
 885         if (NT_STATUS_IS_OK(status)) {
 886                 s = talloc_get_type(c->private_data, struct pipe_connect_state);
 887                 talloc_steal(mem_ctx, s->pipe);
 888                 *p = s->pipe;
 889         }
 890         talloc_free(c);
 891         return status;
 892 }
 893
 894
 895 /*
 896   open a rpc connection to a rpc pipe, using the specified
 897   binding structure to determine the endpoint and options - sync version
 898 */
 899 _PUBLIC_ NTSTATUS dcerpc_pipe_connect_b(TALLOC_CTX *parent_ctx,
 900                                struct dcerpc_pipe **pp,
 901                                const struct dcerpc_binding *binding,
 902                                const struct ndr_interface_table *table,
 903                                struct cli_credentials *credentials,
 904                                struct tevent_context *ev,
 905                                struct loadparm_context *lp_ctx)
 906 {
 907         struct composite_context *c;
 908
 909         c = dcerpc_pipe_connect_b_send(parent_ctx, binding, table,
 910                                        credentials, ev, lp_ctx);
 911         return dcerpc_pipe_connect_b_recv(c, parent_ctx, pp);
 912 }
 913
 914
 915 struct pipe_conn_state {
 916         struct dcerpc_pipe *pipe;
 917 };
 918
 919
 920 static void continue_pipe_connect_b(struct composite_context *ctx);
 921
 922
 923 /*
 924   Initiate rpc connection to a rpc pipe, using the specified string
 925   binding to determine the endpoint and options.
 926   The string is to be parsed to a binding structure first.
 927 */
 928 _PUBLIC_ struct composite_context* dcerpc_pipe_connect_send(TALLOC_CTX *parent_ctx,
 929                                                    const char *binding,
 930                                                    const struct ndr_interface_table *table,
 931                                                    struct cli_credentials *credentials,
 932                                                    struct tevent_context *ev, struct loadparm_context *lp_ctx)
 933 {
 934         struct composite_context *c;
 935         struct pipe_conn_state *s;
 936         struct dcerpc_binding *b;
 937         struct composite_context *pipe_conn_req;
 938
 939         /* composite context allocation and setup */
 940         c = composite_create(parent_ctx, ev);
 941         if (c == NULL) {
 942                 return NULL;
 943         }
 944
 945         s = talloc_zero(c, struct pipe_conn_state);
 946         if (composite_nomem(s, c)) return c;
 947         c->private_data = s;
 948
 949         /* parse binding string to the structure */
 950         c->status = dcerpc_parse_binding(c, binding, &b);
 951         if (!NT_STATUS_IS_OK(c->status)) {
 952                 DEBUG(0, ("Failed to parse dcerpc binding '%s'\n", binding));
 953                 composite_error(c, c->status);
 954                 return c;
 955         }
 956
 957         DEBUG(3, ("Using binding %s\n", dcerpc_binding_string(c, b)));
 958
 959         /*
 960            start connecting to a rpc pipe after binding structure
 961            is established
 962          */
 963         pipe_conn_req = dcerpc_pipe_connect_b_send(c, b, table,
 964                                                    credentials, ev, lp_ctx);
 965         composite_continue(c, pipe_conn_req, continue_pipe_connect_b, c);
 966         return c;
 967 }
 968
 969
 970 /*
 971   Stage 2 of pipe_connect: Receive result of actual pipe connect request
 972   and say if we're done ok
 973 */
 974 static void continue_pipe_connect_b(struct composite_context *ctx)
 975 {
 976         struct composite_context *c = talloc_get_type(ctx->async.private_data,
 977                                                       struct composite_context);
 978         struct pipe_conn_state *s = talloc_get_type(c->private_data,
 979                                                     struct pipe_conn_state);
 980
 981         c->status = dcerpc_pipe_connect_b_recv(ctx, c, &s->pipe);
 982         talloc_steal(s, s->pipe);
 983         if (!composite_is_ok(c)) return;
 984
 985         composite_done(c);
 986 }
 987
 988
 989 /*
 990   Receive result of pipe connect (using binding string) request
 991   and return connected pipe structure.
 992 */
 993 NTSTATUS dcerpc_pipe_connect_recv(struct composite_context *c,
 994                                   TALLOC_CTX *mem_ctx,
 995                                   struct dcerpc_pipe **pp)
 996 {
 997         NTSTATUS status;
 998         struct pipe_conn_state *s;
 999
1000         status = composite_wait(c);
1001         if (NT_STATUS_IS_OK(status)) {
1002                 s = talloc_get_type(c->private_data, struct pipe_conn_state);
1003                 *pp = talloc_steal(mem_ctx, s->pipe);
1004         }
1005         talloc_free(c);
1006         return status;
1007 }
1008
1009
1010 /*
1011   Open a rpc connection to a rpc pipe, using the specified string
1012   binding to determine the endpoint and options - sync version
1013 */
1014 _PUBLIC_ NTSTATUS dcerpc_pipe_connect(TALLOC_CTX *parent_ctx,
1015                              struct dcerpc_pipe **pp,
1016                              const char *binding,
1017                              const struct ndr_interface_table *table,
1018                              struct cli_credentials *credentials,
1019                              struct tevent_context *ev,
1020                              struct loadparm_context *lp_ctx)
1021 {
1022         struct composite_context *c;
1023         c = dcerpc_pipe_connect_send(parent_ctx, binding,
1024                                      table, credentials, ev, lp_ctx);
1025         return dcerpc_pipe_connect_recv(c, parent_ctx, pp);
1026 }
1027