source4/librpc/rpc/dcerpc_secondary.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 "lib/events/events.h"
  29 #include "librpc/rpc/dcerpc.h"
  30 #include "librpc/rpc/dcerpc_proto.h"
  31 #include "auth/credentials/credentials.h"
  32 #include "param/param.h"
  33 #include "libcli/resolve/resolve.h"
  34 #include "lib/util/util_net.h"
  35
  36 struct sec_conn_state {
  37         struct dcerpc_pipe *pipe;
  38         struct dcerpc_pipe *pipe2;
  39         struct dcerpc_binding *binding;
  40 };
  41
  42
  43 static void continue_open_smb(struct composite_context *ctx);
  44 static void continue_open_tcp(struct composite_context *ctx);
  45 static void continue_open_ncalrpc(struct composite_context *ctx);
  46 static void continue_open_ncacn_unix(struct composite_context *ctx);
  47 static void continue_pipe_open(struct composite_context *c);
  48
  49
  50 /*
  51   Send request to create a secondary dcerpc connection from a primary
  52   connection
  53 */
  54 _PUBLIC_ struct composite_context* dcerpc_secondary_connection_send(struct dcerpc_pipe *p,
  55                                                         const struct dcerpc_binding *b)
  56 {
  57         struct composite_context *c;
  58         struct sec_conn_state *s;
  59         struct composite_context *pipe_smb_req;
  60         struct composite_context *pipe_tcp_req;
  61         const char *localaddress = NULL;
  62         struct composite_context *pipe_ncalrpc_req;
  63         const char *ncalrpc_dir = NULL;
  64         struct composite_context *pipe_unix_req;
  65         const char *host;
  66         const char *target_hostname;
  67         const char *endpoint;
  68
  69         /* composite context allocation and setup */
  70         c = composite_create(p, p->conn->event_ctx);
  71         if (c == NULL) return NULL;
  72
  73         s = talloc_zero(c, struct sec_conn_state);
  74         if (composite_nomem(s, c)) return c;
  75         c->private_data = s;
  76
  77         s->pipe     = p;
  78         s->binding  = dcerpc_binding_dup(s, b);
  79         if (composite_nomem(s->binding, c)) return c;
  80
  81         /* initialise second dcerpc pipe based on primary pipe's event context */
  82         s->pipe2 = dcerpc_pipe_init(c, s->pipe->conn->event_ctx);
  83         if (composite_nomem(s->pipe2, c)) return c;
  84
  85         if (DEBUGLEVEL >= 10)
  86                 s->pipe2->conn->packet_log_dir = s->pipe->conn->packet_log_dir;
  87
  88         host = dcerpc_binding_get_string_option(s->binding, "host");
  89         if (host == NULL) {
  90                 /*
  91                  * We may fallback to the host of the given connection
  92                  */
  93                 host = dcerpc_binding_get_string_option(s->pipe->binding,
  94                                                         "host");
  95         }
  96         target_hostname = dcerpc_binding_get_string_option(s->binding, "target_hostname");
  97         if (target_hostname == NULL) {
  98                 /*
  99                  * We may fallback to the target_hostname of the given connection
 100                  */
 101                 target_hostname = dcerpc_binding_get_string_option(s->pipe->binding,
 102                                                                    "target_hostname");
 103         }
 104         endpoint = dcerpc_binding_get_string_option(s->binding, "endpoint");
 105         if (endpoint == NULL) {
 106                 /*
 107                  * We may fallback to the endpoint of the given connection
 108                  */
 109                 endpoint = dcerpc_binding_get_string_option(s->pipe->binding, "endpoint");
 110         }
 111         if (endpoint == NULL) {
 112                 composite_error(c, NT_STATUS_INVALID_PARAMETER_MIX);
 113                 return c;
 114         }
 115
 116         /* open second dcerpc pipe using the same transport as for primary pipe */
 117         switch (s->pipe->conn->transport.transport) {
 118         case NCACN_NP:
 119                 pipe_smb_req = dcerpc_secondary_smb_send(s->pipe->conn,
 120                                                          s->pipe2->conn,
 121                                                          endpoint);
 122                 composite_continue(c, pipe_smb_req, continue_open_smb, c);
 123                 return c;
 124
 125         case NCACN_IP_TCP:
 126                 if (host == NULL) {
 127                         composite_error(c, NT_STATUS_INVALID_PARAMETER_MIX);
 128                         return c;
 129                 }
 130
 131                 if (!is_ipaddress(host)) {
 132                         /*
 133                          * We may fallback to the host of the given connection
 134                          */
 135                         host = dcerpc_binding_get_string_option(s->pipe->binding,
 136                                                                 "host");
 137                         if (host == NULL) {
 138                                 composite_error(c, NT_STATUS_INVALID_PARAMETER_MIX);
 139                                 return c;
 140                         }
 141                         if (!is_ipaddress(host)) {
 142                                 composite_error(c, NT_STATUS_INVALID_PARAMETER_MIX);
 143                                 return c;
 144                         }
 145                 }
 146
 147                 localaddress = dcerpc_binding_get_string_option(s->binding,
 148                                                                 "localaddress");
 149                 if (localaddress == NULL) {
 150                         /*
 151                          * We may fallback to the localaddress of the given connection
 152                          */
 153                         localaddress = dcerpc_binding_get_string_option(s->pipe->binding,
 154                                                                         "localaddress");
 155                 }
 156
 157                 pipe_tcp_req = dcerpc_pipe_open_tcp_send(s->pipe2->conn,
 158                                                          localaddress,
 159                                                          host,
 160                                                          target_hostname,
 161                                                          atoi(endpoint),
 162                                                          resolve_context_init(s));
 163                 composite_continue(c, pipe_tcp_req, continue_open_tcp, c);
 164                 return c;
 165
 166         case NCALRPC:
 167                 ncalrpc_dir = dcerpc_binding_get_string_option(s->binding,
 168                                                                "ncalrpc_dir");
 169                 if (ncalrpc_dir == NULL) {
 170                         ncalrpc_dir = dcerpc_binding_get_string_option(s->pipe->binding,
 171                                                                 "ncalrpc_dir");
 172                 }
 173                 if (ncalrpc_dir == NULL) {
 174                         composite_error(c, NT_STATUS_INVALID_PARAMETER_MIX);
 175                         return c;
 176                 }
 177
 178                 pipe_ncalrpc_req = dcerpc_pipe_open_pipe_send(s->pipe2->conn,
 179                                                               ncalrpc_dir,
 180                                                               endpoint);
 181                 composite_continue(c, pipe_ncalrpc_req, continue_open_ncalrpc, c);
 182                 return c;
 183
 184         case NCACN_UNIX_STREAM:
 185                 pipe_unix_req = dcerpc_pipe_open_unix_stream_send(s->pipe2->conn,
 186                                                                   endpoint);
 187                 composite_continue(c, pipe_unix_req, continue_open_ncacn_unix, c);
 188                 return c;
 189
 190         default:
 191                 /* looks like a transport we don't support */
 192                 composite_error(c, NT_STATUS_NOT_SUPPORTED);
 193         }
 194
 195         return c;
 196 }
 197
 198
 199 /*
 200   Stage 2 of secondary_connection: Receive result of pipe open request on smb
 201 */
 202 static void continue_open_smb(struct composite_context *ctx)
 203 {
 204         struct composite_context *c = talloc_get_type(ctx->async.private_data,
 205                                                       struct composite_context);
 206
 207         c->status = dcerpc_secondary_smb_recv(ctx);
 208         if (!composite_is_ok(c)) return;
 209
 210         continue_pipe_open(c);
 211 }
 212
 213
 214 /*
 215   Stage 2 of secondary_connection: Receive result of pipe open request on tcp/ip
 216 */
 217 static void continue_open_tcp(struct composite_context *ctx)
 218 {
 219         struct composite_context *c = talloc_get_type(ctx->async.private_data,
 220                                                       struct composite_context);
 221         struct sec_conn_state *s = talloc_get_type_abort(c->private_data,
 222                                                          struct sec_conn_state);
 223         char *localaddr = NULL;
 224         char *remoteaddr = NULL;
 225
 226         c->status = dcerpc_pipe_open_tcp_recv(ctx, s, &localaddr, &remoteaddr);
 227         if (!composite_is_ok(c)) return;
 228
 229         c->status = dcerpc_binding_set_string_option(s->binding,
 230                                                      "localaddress",
 231                                                      localaddr);
 232         if (!composite_is_ok(c)) return;
 233
 234         c->status = dcerpc_binding_set_string_option(s->binding,
 235                                                      "host",
 236                                                      remoteaddr);
 237         if (!composite_is_ok(c)) return;
 238
 239         continue_pipe_open(c);
 240 }
 241
 242 /*
 243   Stage 2 of secondary_connection: Receive result of pipe open request on ncalrpc
 244 */
 245 static void continue_open_ncalrpc(struct composite_context *ctx)
 246 {
 247         struct composite_context *c = talloc_get_type(ctx->async.private_data,
 248                                                       struct composite_context);
 249
 250         c->status = dcerpc_pipe_open_pipe_recv(ctx);
 251         if (!composite_is_ok(c)) return;
 252
 253         continue_pipe_open(c);
 254 }
 255
 256 /*
 257   Stage 2 of secondary_connection: Receive result of pipe open request on ncacn_unix
 258 */
 259 static void continue_open_ncacn_unix(struct composite_context *ctx)
 260 {
 261         struct composite_context *c = talloc_get_type(ctx->async.private_data,
 262                                                       struct composite_context);
 263
 264         c->status = dcerpc_pipe_open_unix_stream_recv(ctx);
 265         if (!composite_is_ok(c)) return;
 266
 267         continue_pipe_open(c);
 268 }
 269
 270
 271 /*
 272   Stage 3 of secondary_connection: Get binding data and flags from primary pipe
 273   and say if we're done ok.
 274 */
 275 static void continue_pipe_open(struct composite_context *c)
 276 {
 277         struct sec_conn_state *s;
 278
 279         s = talloc_get_type(c->private_data, struct sec_conn_state);
 280
 281         s->pipe2->conn->flags = s->pipe->conn->flags;
 282         s->pipe2->binding     = dcerpc_binding_dup(s->pipe2, s->binding);
 283         if (composite_nomem(s->pipe2->binding, c)) {
 284                 return;
 285         }
 286
 287         composite_done(c);
 288 }
 289
 290
 291 /*
 292   Receive result of secondary rpc connection request and return
 293   second dcerpc pipe.
 294 */
 295 _PUBLIC_ NTSTATUS dcerpc_secondary_connection_recv(struct composite_context *c,
 296                                           struct dcerpc_pipe **p2)
 297 {
 298         NTSTATUS status = composite_wait(c);
 299         struct sec_conn_state *s;
 300
 301         s = talloc_get_type(c->private_data, struct sec_conn_state);
 302
 303         if (NT_STATUS_IS_OK(status)) {
 304                 *p2 = talloc_steal(s->pipe, s->pipe2);
 305         }
 306
 307         talloc_free(c);
 308         return status;
 309 }
 310
 311 /*
 312   Create a secondary dcerpc connection from a primary connection
 313   - sync version
 314
 315   If the primary is a SMB connection then the secondary connection
 316   will be on the same SMB connection, but using a new fnum
 317 */
 318 _PUBLIC_ NTSTATUS dcerpc_secondary_connection(struct dcerpc_pipe *p,
 319                                      struct dcerpc_pipe **p2,
 320                                      const struct dcerpc_binding *b)
 321 {
 322         struct composite_context *c;
 323
 324         c = dcerpc_secondary_connection_send(p, b);
 325         return dcerpc_secondary_connection_recv(c, p2);
 326 }
 327
 328 /*
 329   Create a secondary DCERPC connection, then bind (and possibly
 330   authenticate) using the supplied credentials.
 331
 332   This creates a second connection, to the same host (and on ncacn_np on the same connection) as the first
 333 */
 334 struct sec_auth_conn_state {
 335         struct dcerpc_pipe *pipe2;
 336         const struct dcerpc_binding *binding;
 337         const struct ndr_interface_table *table;
 338         struct cli_credentials *credentials;
 339         struct composite_context *ctx;
 340         struct loadparm_context *lp_ctx;
 341 };
 342
 343 static void dcerpc_secondary_auth_connection_bind(struct composite_context *ctx);
 344 static void dcerpc_secondary_auth_connection_continue(struct composite_context *ctx);
 345
 346 _PUBLIC_ struct composite_context* dcerpc_secondary_auth_connection_send(struct dcerpc_pipe *p,
 347                                                                 const struct dcerpc_binding *binding,
 348                                                                 const struct ndr_interface_table *table,
 349                                                                 struct cli_credentials *credentials,
 350                                                                 struct loadparm_context *lp_ctx)
 351 {
 352
 353         struct composite_context *c, *secondary_conn_ctx;
 354         struct sec_auth_conn_state *s;
 355
 356         /* composite context allocation and setup */
 357         c = composite_create(p, p->conn->event_ctx);
 358         if (c == NULL) return NULL;
 359
 360         s = talloc_zero(c, struct sec_auth_conn_state);
 361         if (composite_nomem(s, c)) return c;
 362         c->private_data = s;
 363         s->ctx = c;
 364
 365         s->binding  = binding;
 366         s->table    = table;
 367         s->credentials = credentials;
 368         s->lp_ctx = lp_ctx;
 369
 370         secondary_conn_ctx = dcerpc_secondary_connection_send(p, binding);
 371
 372         if (composite_nomem(secondary_conn_ctx, s->ctx)) {
 373                 talloc_free(c);
 374                 return NULL;
 375         }
 376
 377         composite_continue(s->ctx, secondary_conn_ctx, dcerpc_secondary_auth_connection_bind,
 378                            s);
 379         return c;
 380 }
 381
 382 /*
 383   Stage 2 of secondary_auth_connection:
 384   Having made the secondary connection, we will need to do an (authenticated) bind
 385 */
 386 static void dcerpc_secondary_auth_connection_bind(struct composite_context *ctx)
 387 {
 388         struct composite_context *secondary_auth_ctx;
 389         struct sec_auth_conn_state *s = talloc_get_type(ctx->async.private_data,
 390                                                         struct sec_auth_conn_state);
 391
 392         s->ctx->status = dcerpc_secondary_connection_recv(ctx, &s->pipe2);
 393         if (!composite_is_ok(s->ctx)) return;
 394
 395         secondary_auth_ctx = dcerpc_pipe_auth_send(s->pipe2, s->binding, s->table, s->credentials,
 396                                                    s->lp_ctx);
 397         composite_continue(s->ctx, secondary_auth_ctx, dcerpc_secondary_auth_connection_continue, s);
 398
 399 }
 400
 401 /*
 402   Stage 3 of secondary_auth_connection: Receive result of authenticated bind request
 403 */
 404 static void dcerpc_secondary_auth_connection_continue(struct composite_context *ctx)
 405 {
 406         struct sec_auth_conn_state *s = talloc_get_type(ctx->async.private_data,
 407                                                         struct sec_auth_conn_state);
 408
 409         s->ctx->status = dcerpc_pipe_auth_recv(ctx, s, &s->pipe2);
 410         if (!composite_is_ok(s->ctx)) return;
 411
 412         composite_done(s->ctx);
 413 }
 414
 415 /*
 416   Receive an authenticated pipe, created as a secondary connection
 417 */
 418 _PUBLIC_ NTSTATUS dcerpc_secondary_auth_connection_recv(struct composite_context *c,
 419                                                TALLOC_CTX *mem_ctx,
 420                                                struct dcerpc_pipe **p)
 421 {
 422         NTSTATUS status = composite_wait(c);
 423         struct sec_auth_conn_state *s;
 424
 425         s = talloc_get_type(c->private_data, struct sec_auth_conn_state);
 426
 427         if (NT_STATUS_IS_OK(status)) {
 428                 *p = talloc_steal(mem_ctx, s->pipe2);
 429         }
 430
 431         talloc_free(c);
 432         return status;
 433 }
 434
 435 _PUBLIC_ NTSTATUS dcerpc_secondary_auth_connection(struct dcerpc_pipe *p,
 436                                         const struct dcerpc_binding *binding,
 437                                         const struct ndr_interface_table *table,
 438                                         struct cli_credentials *credentials,
 439                                         struct loadparm_context *lp_ctx,
 440                                         TALLOC_CTX *mem_ctx,
 441                                         struct dcerpc_pipe **p2)
 442 {
 443         struct composite_context *c;
 444
 445         c = dcerpc_secondary_auth_connection_send(p, binding, table,
 446                                                   credentials, lp_ctx);
 447         return dcerpc_secondary_auth_connection_recv(c, mem_ctx, p2);
 448 }