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 "auth/credentials/credentials.h"
  31 #include "param/param.h"
  32 #include "libcli/resolve/resolve.h"
  33
  34
  35 struct sec_conn_state {
  36         struct dcerpc_pipe *pipe;
  37         struct dcerpc_pipe *pipe2;
  38         struct dcerpc_binding *binding;
  39         struct smbcli_tree *tree;
  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_pipe(struct composite_context *ctx);
  46 static void continue_pipe_open(struct composite_context *c);
  47
  48
  49 /*
  50   Send request to create a secondary dcerpc connection from a primary
  51   connection
  52 */
  53 struct composite_context* dcerpc_secondary_connection_send(struct dcerpc_pipe *p,
  54                                                            struct dcerpc_binding *b)
  55 {
  56         struct composite_context *c;
  57         struct sec_conn_state *s;
  58         struct composite_context *pipe_smb_req;
  59         struct composite_context *pipe_tcp_req;
  60         struct composite_context *pipe_ncalrpc_req;
  61
  62         /* composite context allocation and setup */
  63         c = composite_create(p, p->conn->event_ctx);
  64         if (c == NULL) return NULL;
  65
  66         s = talloc_zero(c, struct sec_conn_state);
  67         if (composite_nomem(s, c)) return c;
  68         c->private_data = s;
  69
  70         s->pipe     = p;
  71         s->binding  = b;
  72
  73         /* initialise second dcerpc pipe based on primary pipe's event context */
  74         s->pipe2 = dcerpc_pipe_init(c, s->pipe->conn->event_ctx);
  75         if (composite_nomem(s->pipe2, c)) return c;
  76
  77         /* open second dcerpc pipe using the same transport as for primary pipe */
  78         switch (s->pipe->conn->transport.transport) {
  79         case NCACN_NP:
  80                 /* get smb tree of primary dcerpc pipe opened on smb */
  81                 s->tree = dcerpc_smb_tree(s->pipe->conn);
  82                 if (!s->tree) {
  83                         composite_error(c, NT_STATUS_INVALID_PARAMETER);
  84                         return c;
  85                 }
  86
  87                 pipe_smb_req = dcerpc_pipe_open_smb_send(s->pipe2, s->tree,
  88                                                          s->binding->endpoint);
  89                 composite_continue(c, pipe_smb_req, continue_open_smb, c);
  90                 return c;
  91
  92         case NCACN_IP_TCP:
  93                 pipe_tcp_req = dcerpc_pipe_open_tcp_send(s->pipe2->conn,
  94                                                          s->binding->host,
  95                                                          s->binding->target_hostname,
  96                                                          atoi(s->binding->endpoint),
  97                                                          lp_resolve_context(global_loadparm));
  98                 composite_continue(c, pipe_tcp_req, continue_open_tcp, c);
  99                 return c;
 100
 101         case NCALRPC:
 102                 pipe_ncalrpc_req = dcerpc_pipe_open_pipe_send(s->pipe2->conn, lp_ncalrpc_dir(global_loadparm),
 103                                                               s->binding->endpoint);
 104                 composite_continue(c, pipe_ncalrpc_req, continue_open_pipe, c);
 105                 return c;
 106
 107         default:
 108                 /* looks like a transport we don't support */
 109                 composite_error(c, NT_STATUS_NOT_SUPPORTED);
 110         }
 111
 112         return c;
 113 }
 114
 115
 116 /*
 117   Stage 2 of secondary_connection: Receive result of pipe open request on smb
 118 */
 119 static void continue_open_smb(struct composite_context *ctx)
 120 {
 121         struct composite_context *c = talloc_get_type(ctx->async.private_data,
 122                                                       struct composite_context);
 123
 124         c->status = dcerpc_pipe_open_smb_recv(ctx);
 125         if (!composite_is_ok(c)) return;
 126
 127         continue_pipe_open(c);
 128 }
 129
 130
 131 /*
 132   Stage 2 of secondary_connection: Receive result of pipe open request on tcp/ip
 133 */
 134 static void continue_open_tcp(struct composite_context *ctx)
 135 {
 136         struct composite_context *c = talloc_get_type(ctx->async.private_data,
 137                                                       struct composite_context);
 138
 139         c->status = dcerpc_pipe_open_tcp_recv(ctx);
 140         if (!composite_is_ok(c)) return;
 141
 142         continue_pipe_open(c);
 143 }
 144
 145
 146 /*
 147   Stage 2 of secondary_connection: Receive result of pipe open request on ncalrpc
 148 */
 149 static void continue_open_pipe(struct composite_context *ctx)
 150 {
 151         struct composite_context *c = talloc_get_type(ctx->async.private_data,
 152                                                       struct composite_context);
 153
 154         c->status = dcerpc_pipe_open_pipe_recv(ctx);
 155         if (!composite_is_ok(c)) return;
 156
 157         continue_pipe_open(c);
 158 }
 159
 160
 161 /*
 162   Stage 3 of secondary_connection: Get binding data and flags from primary pipe
 163   and say if we're done ok.
 164 */
 165 static void continue_pipe_open(struct composite_context *c)
 166 {
 167         struct sec_conn_state *s;
 168
 169         s = talloc_get_type(c->private_data, struct sec_conn_state);
 170
 171         s->pipe2->conn->flags = s->pipe->conn->flags;
 172         s->pipe2->binding     = s->binding;
 173         if (!talloc_reference(s->pipe2, s->binding)) {
 174                 composite_error(c, NT_STATUS_NO_MEMORY);
 175                 return;
 176         }
 177
 178         composite_done(c);
 179 }
 180
 181
 182 /*
 183   Receive result of secondary rpc connection request and return
 184   second dcerpc pipe.
 185 */
 186 NTSTATUS dcerpc_secondary_connection_recv(struct composite_context *c,
 187                                           struct dcerpc_pipe **p2)
 188 {
 189         NTSTATUS status = composite_wait(c);
 190         struct sec_conn_state *s;
 191
 192         s = talloc_get_type(c->private_data, struct sec_conn_state);
 193
 194         if (NT_STATUS_IS_OK(status)) {
 195                 *p2 = talloc_steal(s->pipe, s->pipe2);
 196         }
 197
 198         talloc_free(c);
 199         return status;
 200 }
 201
 202 /*
 203   Create a secondary dcerpc connection from a primary connection
 204   - sync version
 205
 206   If the primary is a SMB connection then the secondary connection
 207   will be on the same SMB connection, but using a new fnum
 208 */
 209 NTSTATUS dcerpc_secondary_connection(struct dcerpc_pipe *p,
 210                                      struct dcerpc_pipe **p2,
 211                                      struct dcerpc_binding *b)
 212 {
 213         struct composite_context *c;
 214
 215         c = dcerpc_secondary_connection_send(p, b);
 216         return dcerpc_secondary_connection_recv(c, p2);
 217 }
 218
 219 /*
 220   Create a secondary DCERPC connection, then bind (and possibly
 221   authenticate) using the supplied credentials.
 222
 223   This creates a second connection, to the same host (and on ncacn_np on the same connection) as the first
 224 */
 225 struct sec_auth_conn_state {
 226         struct dcerpc_pipe *pipe2;
 227         struct dcerpc_binding *binding;
 228         const struct ndr_interface_table *table;
 229         struct cli_credentials *credentials;
 230         struct composite_context *ctx;
 231         struct loadparm_context *lp_ctx;
 232 };
 233
 234 static void dcerpc_secondary_auth_connection_bind(struct composite_context *ctx);
 235 static void dcerpc_secondary_auth_connection_continue(struct composite_context *ctx);
 236
 237 struct composite_context* dcerpc_secondary_auth_connection_send(struct dcerpc_pipe *p,
 238                                                                 struct dcerpc_binding *binding,
 239                                                                 const struct ndr_interface_table *table,
 240                                                                 struct cli_credentials *credentials,
 241                                                                 struct loadparm_context *lp_ctx)
 242 {
 243
 244         struct composite_context *c, *secondary_conn_ctx;
 245         struct sec_auth_conn_state *s;
 246
 247         /* composite context allocation and setup */
 248         c = composite_create(p, p->conn->event_ctx);
 249         if (c == NULL) return NULL;
 250
 251         s = talloc_zero(c, struct sec_auth_conn_state);
 252         if (composite_nomem(s, c)) return c;
 253         c->private_data = s;
 254         s->ctx = c;
 255
 256         s->binding  = binding;
 257         s->table    = table;
 258         s->credentials = credentials;
 259         s->lp_ctx = lp_ctx;
 260
 261         secondary_conn_ctx = dcerpc_secondary_connection_send(p, binding);
 262
 263         if (composite_nomem(secondary_conn_ctx, s->ctx)) {
 264                 talloc_free(c);
 265                 return NULL;
 266         }
 267
 268         composite_continue(s->ctx, secondary_conn_ctx, dcerpc_secondary_auth_connection_bind,
 269                            s);
 270         return c;
 271 }
 272
 273 /*
 274   Stage 2 of secondary_auth_connection:
 275   Having made the secondary connection, we will need to do an (authenticated) bind
 276 */
 277 static void dcerpc_secondary_auth_connection_bind(struct composite_context *ctx)
 278 {
 279         struct composite_context *secondary_auth_ctx;
 280         struct sec_auth_conn_state *s = talloc_get_type(ctx->async.private_data,
 281                                                         struct sec_auth_conn_state);
 282
 283         s->ctx->status = dcerpc_secondary_connection_recv(ctx, &s->pipe2);
 284         if (!composite_is_ok(s->ctx)) return;
 285
 286         secondary_auth_ctx = dcerpc_pipe_auth_send(s->pipe2, s->binding, s->table, s->credentials,
 287                                                    s->lp_ctx);
 288         composite_continue(s->ctx, secondary_auth_ctx, dcerpc_secondary_auth_connection_continue, s);
 289
 290 }
 291
 292 /*
 293   Stage 3 of secondary_auth_connection: Receive result of authenticated bind request
 294 */
 295 static void dcerpc_secondary_auth_connection_continue(struct composite_context *ctx)
 296 {
 297         struct sec_auth_conn_state *s = talloc_get_type(ctx->async.private_data,
 298                                                         struct sec_auth_conn_state);
 299
 300         s->ctx->status = dcerpc_pipe_auth_recv(ctx, s, &s->pipe2);
 301         if (!composite_is_ok(s->ctx)) return;
 302
 303         composite_done(s->ctx);
 304 }
 305
 306 /*
 307   Receive an authenticated pipe, created as a secondary connection
 308 */
 309 NTSTATUS dcerpc_secondary_auth_connection_recv(struct composite_context *c,
 310                                                TALLOC_CTX *mem_ctx,
 311                                                struct dcerpc_pipe **p)
 312 {
 313         NTSTATUS status = composite_wait(c);
 314         struct sec_auth_conn_state *s;
 315
 316         s = talloc_get_type(c->private_data, struct sec_auth_conn_state);
 317
 318         if (NT_STATUS_IS_OK(status)) {
 319                 *p = talloc_steal(mem_ctx, s->pipe2);
 320         }
 321
 322         talloc_free(c);
 323         return status;
 324 }