source/libcli/smb2/connect.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    SMB2 composite connection setup
   5
   6    Copyright (C) Andrew Tridgell 2005
   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 "libcli/raw/libcliraw.h"
  24 #include "libcli/raw/raw_proto.h"
  25 #include "libcli/smb2/smb2.h"
  26 #include "libcli/smb2/smb2_calls.h"
  27 #include "libcli/composite/composite.h"
  28 #include "libcli/resolve/resolve.h"
  29 #include "param/param.h"
  30
  31 struct smb2_connect_state {
  32         struct cli_credentials *credentials;
  33         struct resolve_context *resolve_ctx;
  34         const char *host;
  35         const char *share;
  36         struct smbcli_options options;
  37         struct smb2_negprot negprot;
  38         struct smb2_tree_connect tcon;
  39         struct smb2_session *session;
  40         struct smb2_tree *tree;
  41 };
  42
  43 /*
  44   continue after tcon reply
  45 */
  46 static void continue_tcon(struct smb2_request *req)
  47 {
  48         struct composite_context *c = talloc_get_type(req->async.private_data,
  49                                                       struct composite_context);
  50         struct smb2_connect_state *state = talloc_get_type(c->private_data,
  51                                                            struct smb2_connect_state);
  52
  53         c->status = smb2_tree_connect_recv(req, &state->tcon);
  54         if (!composite_is_ok(c)) return;
  55
  56         state->tree->tid = state->tcon.out.tid;
  57
  58         composite_done(c);
  59 }
  60
  61 /*
  62   continue after a session setup
  63 */
  64 static void continue_session(struct composite_context *creq)
  65 {
  66         struct composite_context *c = talloc_get_type(creq->async.private_data,
  67                                                       struct composite_context);
  68         struct smb2_connect_state *state = talloc_get_type(c->private_data,
  69                                                            struct smb2_connect_state);
  70         struct smb2_request *req;
  71
  72         c->status = smb2_session_setup_spnego_recv(creq);
  73         if (!composite_is_ok(c)) return;
  74
  75         state->tree = smb2_tree_init(state->session, state, true);
  76         if (composite_nomem(state->tree, c)) return;
  77
  78         state->tcon.in.reserved = 0;
  79         state->tcon.in.path     = talloc_asprintf(state, "\\\\%s\\%s",
  80                                                   state->host, state->share);
  81         if (composite_nomem(state->tcon.in.path, c)) return;
  82
  83         req = smb2_tree_connect_send(state->tree, &state->tcon);
  84         if (composite_nomem(req, c)) return;
  85
  86         req->async.fn = continue_tcon;
  87         req->async.private_data = c;
  88 }
  89
  90 /*
  91   continue after negprot reply
  92 */
  93 static void continue_negprot(struct smb2_request *req)
  94 {
  95         struct composite_context *c = talloc_get_type(req->async.private_data,
  96                                                       struct composite_context);
  97         struct smb2_connect_state *state = talloc_get_type(c->private_data,
  98                                                            struct smb2_connect_state);
  99         struct smb2_transport *transport = req->transport;
 100         struct composite_context *creq;
 101
 102         c->status = smb2_negprot_recv(req, c, &state->negprot);
 103         if (!composite_is_ok(c)) return;
 104
 105         transport->negotiate.system_time = state->negprot.out.system_time;
 106         transport->negotiate.server_start_time = state->negprot.out.server_start_time;
 107         transport->negotiate.security_mode = state->negprot.out.security_mode;
 108
 109         switch (transport->options.signing) {
 110         case SMB_SIGNING_OFF:
 111                 if (transport->negotiate.security_mode & SMB2_NEGOTIATE_SIGNING_REQUIRED) {
 112                         composite_error(c, NT_STATUS_ACCESS_DENIED);
 113                         return;
 114                 }
 115                 transport->signing.doing_signing = false;
 116                 break;
 117         case SMB_SIGNING_SUPPORTED:
 118         case SMB_SIGNING_AUTO:
 119                 if (transport->negotiate.security_mode & SMB2_NEGOTIATE_SIGNING_REQUIRED) {
 120                         transport->signing.doing_signing = true;
 121                 } else {
 122                         transport->signing.doing_signing = false;
 123                 }
 124                 break;
 125         case SMB_SIGNING_REQUIRED:
 126                 if (transport->negotiate.security_mode & SMB2_NEGOTIATE_SIGNING_ENABLED) {
 127                         transport->signing.doing_signing = true;
 128                 } else {
 129                         composite_error(c, NT_STATUS_ACCESS_DENIED);
 130                         return;
 131                 }
 132                 break;
 133         }
 134
 135
 136         state->session = smb2_session_init(transport, global_loadparm, state, true);
 137         if (composite_nomem(state->session, c)) return;
 138
 139         creq = smb2_session_setup_spnego_send(state->session, state->credentials);
 140
 141         composite_continue(c, creq, continue_session, c);
 142 }
 143
 144 /*
 145   continue after a socket connect completes
 146 */
 147 static void continue_socket(struct composite_context *creq)
 148 {
 149         struct composite_context *c = talloc_get_type(creq->async.private_data,
 150                                                       struct composite_context);
 151         struct smb2_connect_state *state = talloc_get_type(c->private_data,
 152                                                            struct smb2_connect_state);
 153         struct smbcli_socket *sock;
 154         struct smb2_transport *transport;
 155         struct smb2_request *req;
 156         uint16_t dialects[2];
 157
 158         c->status = smbcli_sock_connect_recv(creq, state, &sock);
 159         if (!composite_is_ok(c)) return;
 160
 161         transport = smb2_transport_init(sock, state, &state->options);
 162         if (composite_nomem(transport, c)) return;
 163
 164         ZERO_STRUCT(state->negprot);
 165         state->negprot.in.dialect_count = 2;
 166         switch (transport->options.signing) {
 167         case SMB_SIGNING_OFF:
 168                 state->negprot.in.security_mode = 0;
 169                 break;
 170         case SMB_SIGNING_SUPPORTED:
 171         case SMB_SIGNING_AUTO:
 172                 state->negprot.in.security_mode = SMB2_NEGOTIATE_SIGNING_ENABLED;
 173                 break;
 174         case SMB_SIGNING_REQUIRED:
 175                 state->negprot.in.security_mode =
 176                         SMB2_NEGOTIATE_SIGNING_ENABLED | SMB2_NEGOTIATE_SIGNING_REQUIRED;
 177                 break;
 178         }
 179         state->negprot.in.capabilities  = 0;
 180         unix_to_nt_time(&state->negprot.in.start_time, time(NULL));
 181         dialects[0] = 0;
 182         dialects[1] = SMB2_DIALECT_REVISION;
 183         state->negprot.in.dialects = dialects;
 184
 185         req = smb2_negprot_send(transport, &state->negprot);
 186         if (composite_nomem(req, c)) return;
 187
 188         req->async.fn = continue_negprot;
 189         req->async.private_data = c;
 190 }
 191
 192
 193 /*
 194   continue after a resolve finishes
 195 */
 196 static void continue_resolve(struct composite_context *creq)
 197 {
 198         struct composite_context *c = talloc_get_type(creq->async.private_data,
 199                                                       struct composite_context);
 200         struct smb2_connect_state *state = talloc_get_type(c->private_data,
 201                                                            struct smb2_connect_state);
 202         const char *addr;
 203         const char *ports[2] = { "445", NULL };
 204
 205         c->status = resolve_name_recv(creq, state, &addr);
 206         if (!composite_is_ok(c)) return;
 207
 208         creq = smbcli_sock_connect_send(state, addr, ports, state->host, state->resolve_ctx, c->event_ctx);
 209
 210         composite_continue(c, creq, continue_socket, c);
 211 }
 212
 213 /*
 214   a composite function that does a full negprot/sesssetup/tcon, returning
 215   a connected smb2_tree
 216  */
 217 struct composite_context *smb2_connect_send(TALLOC_CTX *mem_ctx,
 218                                             const char *host,
 219                                             const char *share,
 220                                             struct resolve_context *resolve_ctx,
 221                                             struct cli_credentials *credentials,
 222                                             struct event_context *ev,
 223                                             struct smbcli_options *options)
 224 {
 225         struct composite_context *c;
 226         struct smb2_connect_state *state;
 227         struct nbt_name name;
 228         struct composite_context *creq;
 229
 230         c = composite_create(mem_ctx, ev);
 231         if (c == NULL) return NULL;
 232
 233         state = talloc(c, struct smb2_connect_state);
 234         if (composite_nomem(state, c)) return c;
 235         c->private_data = state;
 236
 237         state->credentials = credentials;
 238         state->options = *options;
 239         state->host = talloc_strdup(c, host);
 240         if (composite_nomem(state->host, c)) return c;
 241         state->share = talloc_strdup(c, share);
 242         if (composite_nomem(state->share, c)) return c;
 243         state->resolve_ctx = talloc_reference(state, resolve_ctx);
 244
 245         ZERO_STRUCT(name);
 246         name.name = host;
 247
 248         creq = resolve_name_send(resolve_ctx, &name, c->event_ctx);
 249         composite_continue(c, creq, continue_resolve, c);
 250         return c;
 251 }
 252
 253 /*
 254   receive a connect reply
 255 */
 256 NTSTATUS smb2_connect_recv(struct composite_context *c, TALLOC_CTX *mem_ctx,
 257                            struct smb2_tree **tree)
 258 {
 259         NTSTATUS status;
 260         struct smb2_connect_state *state = talloc_get_type(c->private_data,
 261                                                            struct smb2_connect_state);
 262         status = composite_wait(c);
 263         if (NT_STATUS_IS_OK(status)) {
 264                 *tree = talloc_steal(mem_ctx, state->tree);
 265         }
 266         talloc_free(c);
 267         return status;
 268 }
 269
 270 /*
 271   sync version of smb2_connect
 272 */
 273 NTSTATUS smb2_connect(TALLOC_CTX *mem_ctx,
 274                       const char *host, const char *share,
 275                       struct resolve_context *resolve_ctx,
 276                       struct cli_credentials *credentials,
 277                       struct smb2_tree **tree,
 278                       struct event_context *ev,
 279                       struct smbcli_options *options)
 280 {
 281         struct composite_context *c = smb2_connect_send(mem_ctx, host, share,
 282                                                         resolve_ctx,
 283                                                         credentials, ev, options);
 284         return smb2_connect_recv(c, mem_ctx, tree);
 285 }