source/smb_server/smb2/tcon.c

   1 /*
   2    Unix SMB2 implementation.
   3
   4    Copyright (C) Stefan Metzmacher      2005
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 2 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software
  18    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19 */
  20
  21 #include "includes.h"
  22 #include "libcli/smb2/smb2.h"
  23 #include "libcli/smb2/smb2_calls.h"
  24 #include "smb_server/smb_server.h"
  25 #include "smb_server/service_smb_proto.h"
  26 #include "smb_server/smb2/smb2_server.h"
  27 #include "librpc/gen_ndr/security.h"
  28 #include "smbd/service_stream.h"
  29 #include "ntvfs/ntvfs.h"
  30
  31 /*
  32   send an oplock break request to a client
  33 */
  34 static NTSTATUS smb2srv_send_oplock_break(void *p, struct ntvfs_handle *ntvfs, uint8_t level)
  35 {
  36         DEBUG(0,("TODO: we don't pass SMB2 oplock breaks to the Clients yet!\n"));
  37         return NT_STATUS_OK;
  38 }
  39
  40 struct ntvfs_handle *smb2srv_pull_handle(struct smb2srv_request *req, const uint8_t *base, uint_t offset)
  41 {
  42         struct smbsrv_tcon *tcon;
  43         struct smbsrv_handle *handle;
  44         uint64_t hid;
  45         uint32_t tid;
  46         uint32_t pad;
  47
  48         /*
  49          * if there're chained requests used the cached handle
  50          *
  51          * TODO: check if this also correct when the given handle
  52          *       isn't all 0xFF.
  53          */
  54         if (req->chained_file_handle) {
  55                 base = req->chained_file_handle;
  56                 offset = 0;
  57         }
  58
  59         hid = BVAL(base, offset);
  60         tid = IVAL(base, offset + 8);
  61         pad = IVAL(base, offset + 12);
  62
  63         if (pad != UINT32_MAX) {
  64                 return NULL;
  65         }
  66
  67         /* if it's the wildcard handle, don't waste time to search it... */
  68         if (hid == UINT64_MAX && tid == UINT32_MAX) {
  69                 return NULL;
  70         }
  71
  72         /*
  73          * the handle can belong to a different tcon
  74          * as that TID in the SMB2 header says, but
  75          * the request should succeed nevertheless!
  76          *
  77          * because if this we put the 32 bit TID into the
  78          * 128 bit handle, so that we can extract the tcon from the
  79          * handle
  80          */
  81         tcon = req->tcon;
  82         if (tid != req->tcon->tid) {
  83                 tcon = smbsrv_smb2_tcon_find(req->session, tid, req->request_time);
  84                 if (!tcon) {
  85                         return NULL;
  86                 }
  87         }
  88
  89         handle = smbsrv_smb2_handle_find(tcon, hid, req->request_time);
  90         if (!handle) {
  91                 return NULL;
  92         }
  93
  94         /*
  95          * as the smb2srv_tcon is a child object of the smb2srv_session
  96          * the handle belongs to the correct session!
  97          *
  98          * Note: no check is needed here for SMB2
  99          */
 100
 101         /*
 102          * as the handle may have overwritten the tcon
 103          * we need to set it on the request so that the
 104          * correct ntvfs context will be used for the ntvfs_*() request
 105          */
 106         req->tcon = tcon;
 107         return handle->ntvfs;
 108 }
 109
 110 void smb2srv_push_handle(uint8_t *base, uint_t offset, struct ntvfs_handle *ntvfs)
 111 {
 112         struct smbsrv_handle *handle = talloc_get_type(ntvfs->frontend_data.private_data,
 113                                        struct smbsrv_handle);
 114
 115         /*
 116          * the handle is 128 bit on the wire
 117          */
 118         SBVAL(base, offset,     handle->hid);
 119         SIVAL(base, offset + 8, handle->tcon->tid);
 120         SIVAL(base, offset + 12,UINT32_MAX);
 121 }
 122
 123 static NTSTATUS smb2srv_handle_create_new(void *private_data, struct ntvfs_request *ntvfs, struct ntvfs_handle **_h)
 124 {
 125         struct smb2srv_request *req = talloc_get_type(ntvfs->frontend_data.private_data,
 126                                       struct smb2srv_request);
 127         struct smbsrv_handle *handle;
 128         struct ntvfs_handle *h;
 129
 130         handle = smbsrv_handle_new(req->session, req->tcon, req, req->request_time);
 131         if (!handle) return NT_STATUS_INSUFFICIENT_RESOURCES;
 132
 133         h = talloc_zero(handle, struct ntvfs_handle);
 134         if (!h) goto nomem;
 135
 136         /*
 137          * note: we don't set handle->ntvfs yet,
 138          *       this will be done by smbsrv_handle_make_valid()
 139          *       this makes sure the handle is invalid for clients
 140          *       until the ntvfs subsystem has made it valid
 141          */
 142         h->ctx          = ntvfs->ctx;
 143         h->session_info = ntvfs->session_info;
 144         h->smbpid       = ntvfs->smbpid;
 145
 146         h->frontend_data.private_data = handle;
 147
 148         *_h = h;
 149         return NT_STATUS_OK;
 150 nomem:
 151         talloc_free(handle);
 152         return NT_STATUS_NO_MEMORY;
 153 }
 154
 155 static NTSTATUS smb2srv_handle_make_valid(void *private_data, struct ntvfs_handle *h)
 156 {
 157         struct smbsrv_tcon *tcon = talloc_get_type(private_data, struct smbsrv_tcon);
 158         struct smbsrv_handle *handle = talloc_get_type(h->frontend_data.private_data,
 159                                                        struct smbsrv_handle);
 160         /* this tells the frontend that the handle is valid */
 161         handle->ntvfs = h;
 162         /* this moves the smbsrv_request to the smbsrv_tcon memory context */
 163         talloc_steal(tcon, handle);
 164         return NT_STATUS_OK;
 165 }
 166
 167 static void smb2srv_handle_destroy(void *private_data, struct ntvfs_handle *h)
 168 {
 169         struct smbsrv_handle *handle = talloc_get_type(h->frontend_data.private_data,
 170                                                        struct smbsrv_handle);
 171         talloc_free(handle);
 172 }
 173
 174 static struct ntvfs_handle *smb2srv_handle_search_by_wire_key(void *private_data, struct ntvfs_request *ntvfs, const DATA_BLOB *key)
 175 {
 176         return NULL;
 177 }
 178
 179 static DATA_BLOB smb2srv_handle_get_wire_key(void *private_data, struct ntvfs_handle *handle, TALLOC_CTX *mem_ctx)
 180 {
 181         return data_blob(NULL, 0);
 182 }
 183
 184 static NTSTATUS smb2srv_tcon_backend(struct smb2srv_request *req, union smb_tcon *io)
 185 {
 186         struct smbsrv_tcon *tcon;
 187         NTSTATUS status;
 188         enum ntvfs_type type;
 189         uint16_t type_smb2;
 190         uint32_t unknown2;
 191         const char *service = io->smb2.in.path;
 192         struct share_config *scfg;
 193         const char *sharetype;
 194
 195         if (strncmp(service, "\\\\", 2) == 0) {
 196                 const char *p = strchr(service+2, '\\');
 197                 if (p) {
 198                         service = p + 1;
 199                 }
 200         }
 201
 202         status = share_get_config(req, req->smb_conn->share_context, service, &scfg);
 203         if (!NT_STATUS_IS_OK(status)) {
 204                 DEBUG(0,("smb2srv_tcon_backend: couldn't find service %s\n", service));
 205                 return NT_STATUS_BAD_NETWORK_NAME;
 206         }
 207
 208         if (!socket_check_access(req->smb_conn->connection->socket,
 209                                  scfg->name,
 210                                  share_string_list_option(req, scfg, SHARE_HOSTS_ALLOW),
 211                                  share_string_list_option(req, scfg, SHARE_HOSTS_DENY))) {
 212                 return NT_STATUS_ACCESS_DENIED;
 213         }
 214
 215         /* work out what sort of connection this is */
 216         sharetype = share_string_option(scfg, SHARE_TYPE, "DISK");
 217         if (sharetype && strcmp(sharetype, "IPC") == 0) {
 218                 type = NTVFS_IPC;
 219                 type_smb2 = 0x0002;
 220                 unknown2 = 0x00000030;
 221         } else if (sharetype && strcmp(sharetype, "PRINTER") == 0) {
 222                 type = NTVFS_PRINT;
 223                 type_smb2 = 0x0003;
 224                 unknown2 = 0x00000000;
 225         } else {
 226                 type = NTVFS_DISK;
 227                 type_smb2 = 0x0001;
 228                 unknown2 = 0x00000800;
 229         }
 230
 231         tcon = smbsrv_smb2_tcon_new(req->session, scfg->name);
 232         if (!tcon) {
 233                 DEBUG(0,("smb2srv_tcon_backend: Couldn't find free connection.\n"));
 234                 return NT_STATUS_INSUFFICIENT_RESOURCES;
 235         }
 236         req->tcon = tcon;
 237
 238         /* init ntvfs function pointers */
 239         status = ntvfs_init_connection(tcon, scfg, type,
 240                                        req->smb_conn->negotiate.protocol,
 241                                        req->smb_conn->connection->event.ctx,
 242                                        req->smb_conn->connection->msg_ctx,
 243                                        req->smb_conn->connection->server_id,
 244                                        &tcon->ntvfs);
 245         if (!NT_STATUS_IS_OK(status)) {
 246                 DEBUG(0, ("smb2srv_tcon_backend: ntvfs_init_connection failed for service %s\n",
 247                           scfg->name));
 248                 goto failed;
 249         }
 250
 251         status = ntvfs_set_oplock_handler(tcon->ntvfs, smb2srv_send_oplock_break, tcon);
 252         if (!NT_STATUS_IS_OK(status)) {
 253                 DEBUG(0,("smb2srv_tcon_backend: NTVFS failed to set the oplock handler!\n"));
 254                 goto failed;
 255         }
 256
 257         status = ntvfs_set_addr_callbacks(tcon->ntvfs, smbsrv_get_my_addr, smbsrv_get_peer_addr, req->smb_conn);
 258         if (!NT_STATUS_IS_OK(status)) {
 259                 DEBUG(0,("smb2srv_tcon_backend: NTVFS failed to set the addr callbacks!\n"));
 260                 goto failed;
 261         }
 262
 263         status = ntvfs_set_handle_callbacks(tcon->ntvfs,
 264                                             smb2srv_handle_create_new,
 265                                             smb2srv_handle_make_valid,
 266                                             smb2srv_handle_destroy,
 267                                             smb2srv_handle_search_by_wire_key,
 268                                             smb2srv_handle_get_wire_key,
 269                                             tcon);
 270         if (!NT_STATUS_IS_OK(status)) {
 271                 DEBUG(0,("smb2srv_tcon_backend: NTVFS failed to set the handle callbacks!\n"));
 272                 goto failed;
 273         }
 274
 275         req->ntvfs = ntvfs_request_create(req->tcon->ntvfs, req,
 276                                           req->session->session_info,
 277                                           0, /* TODO: fill in PID */
 278                                           req->request_time,
 279                                           req, NULL, 0);
 280         if (!req->ntvfs) {
 281                 status = NT_STATUS_NO_MEMORY;
 282                 goto failed;
 283         }
 284
 285         /* Invoke NTVFS connection hook */
 286         status = ntvfs_connect(req->ntvfs, scfg->name);
 287         if (!NT_STATUS_IS_OK(status)) {
 288                 DEBUG(0,("smb2srv_tcon_backend: NTVFS ntvfs_connect() failed!\n"));
 289                 goto failed;
 290         }
 291
 292         io->smb2.out.unknown1   = type_smb2; /* 1 - DISK, 2 - Print, 3 - IPC */
 293         io->smb2.out.unknown2   = unknown2;
 294         io->smb2.out.unknown3   = 0x00000000;
 295         io->smb2.out.access_mask= SEC_RIGHTS_FILE_ALL;
 296
 297         io->smb2.out.tid        = tcon->tid;
 298
 299         return NT_STATUS_OK;
 300
 301 failed:
 302         req->tcon = NULL;
 303         talloc_free(tcon);
 304         return status;
 305 }
 306
 307 static void smb2srv_tcon_send(struct smb2srv_request *req, union smb_tcon *io)
 308 {
 309         uint16_t unknown1;
 310
 311         if (!NT_STATUS_IS_OK(req->status)) {
 312                 smb2srv_send_error(req, req->status);
 313                 return;
 314         }
 315         if (io->smb2.out.unknown1 == 0x0002) {
 316                 /* if it's an IPC share vista returns 0x0005 */
 317                 unknown1 = 0x0005;
 318         } else {
 319                 unknown1 = 0x0001;
 320         }
 321
 322         SMB2SRV_CHECK(smb2srv_setup_reply(req, 0x10, False, 0));
 323
 324         SIVAL(req->out.hdr,     SMB2_HDR_TID,   io->smb2.out.tid);
 325         SSVAL(req->out.hdr,     SMB2_HDR_UNKNOWN1,unknown1);
 326
 327         SSVAL(req->out.body,    0x02,           io->smb2.out.unknown1);
 328         SIVAL(req->out.body,    0x04,           io->smb2.out.unknown2);
 329         SIVAL(req->out.body,    0x08,           io->smb2.out.unknown3);
 330         SIVAL(req->out.body,    0x0C,           io->smb2.out.access_mask);
 331
 332         smb2srv_send_reply(req);
 333 }
 334
 335 void smb2srv_tcon_recv(struct smb2srv_request *req)
 336 {
 337         union smb_tcon *io;
 338
 339         SMB2SRV_CHECK_BODY_SIZE(req, 0x08, True);
 340         SMB2SRV_TALLOC_IO_PTR(io, union smb_tcon);
 341
 342         io->smb2.level          = RAW_TCON_SMB2;
 343         io->smb2.in.unknown1    = SVAL(req->in.body, 0x02);
 344         SMB2SRV_CHECK(smb2_pull_o16s16_string(&req->in, io, req->in.body+0x04, &io->smb2.in.path));
 345
 346         req->status = smb2srv_tcon_backend(req, io);
 347
 348         if (req->control_flags & SMB2SRV_REQ_CTRL_FLAG_NOT_REPLY) {
 349                 talloc_free(req);
 350                 return;
 351         }
 352         smb2srv_tcon_send(req, io);
 353 }
 354
 355 static NTSTATUS smb2srv_tdis_backend(struct smb2srv_request *req)
 356 {
 357         /* TODO: call ntvfs backends to close file of this tcon */
 358         talloc_free(req->tcon);
 359         req->tcon = NULL;
 360         return NT_STATUS_OK;
 361 }
 362
 363 static void smb2srv_tdis_send(struct smb2srv_request *req)
 364 {
 365         NTSTATUS status;
 366
 367         if (NT_STATUS_IS_ERR(req->status)) {
 368                 smb2srv_send_error(req, req->status);
 369                 return;
 370         }
 371
 372         status = smb2srv_setup_reply(req, 0x04, False, 0);
 373         if (!NT_STATUS_IS_OK(status)) {
 374                 smbsrv_terminate_connection(req->smb_conn, nt_errstr(status));
 375                 talloc_free(req);
 376                 return;
 377         }
 378
 379         SSVAL(req->out.body, 0x02, 0);
 380
 381         smb2srv_send_reply(req);
 382 }
 383
 384 void smb2srv_tdis_recv(struct smb2srv_request *req)
 385 {
 386         uint16_t _pad;
 387
 388         SMB2SRV_CHECK_BODY_SIZE(req, 0x04, False);
 389
 390         _pad    = SVAL(req->in.body, 0x02);
 391
 392         req->status = smb2srv_tdis_backend(req);
 393
 394         if (req->control_flags & SMB2SRV_REQ_CTRL_FLAG_NOT_REPLY) {
 395                 talloc_free(req);
 396                 return;
 397         }
 398         smb2srv_tdis_send(req);
 399 }