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