source4/smb_server/smb2/fileio.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 3 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, see <http://www.gnu.org/licenses/>.
  18 */
  19
  20 #include "includes.h"
  21 #include "libcli/smb2/smb2.h"
  22 #include "libcli/smb2/smb2_calls.h"
  23 #include "smb_server/smb_server.h"
  24 #include "smb_server/smb2/smb2_server.h"
  25 #include "ntvfs/ntvfs.h"
  26 #include "libcli/raw/raw_proto.h"
  27 #include "librpc/gen_ndr/ndr_security.h"
  28
  29 static void smb2srv_create_send(struct ntvfs_request *ntvfs)
  30 {
  31         struct smb2srv_request *req;
  32         union smb_open *io;
  33         DATA_BLOB blob;
  34
  35         SMB2SRV_CHECK_ASYNC_STATUS(io, union smb_open);
  36
  37         /* setup the blobs we should give in the reply */
  38         if (io->smb2.out.maximal_access != 0) {
  39                 uint32_t data[2];
  40                 SIVAL(data, 0, 0);
  41                 SIVAL(data, 4, io->smb2.out.maximal_access);
  42                 SMB2SRV_CHECK(smb2_create_blob_add(req, &io->smb2.out.blobs,
  43                                                    SMB2_CREATE_TAG_MXAC,
  44                                                    data_blob_const(data, 8)));
  45         }
  46
  47         if (IVAL(io->smb2.out.on_disk_id, 0) != 0) {
  48                 SMB2SRV_CHECK(smb2_create_blob_add(req, &io->smb2.out.blobs,
  49                                                    SMB2_CREATE_TAG_QFID,
  50                                                    data_blob_const(io->smb2.out.on_disk_id, 32)));
  51         }
  52
  53         SMB2SRV_CHECK(smb2_create_blob_push(req, &blob, io->smb2.out.blobs));
  54         SMB2SRV_CHECK(smb2srv_setup_reply(req, 0x58, true, blob.length));
  55
  56         SCVAL(req->out.body,    0x02,   io->smb2.out.oplock_level);
  57         SCVAL(req->out.body,    0x03,   io->smb2.out.reserved);
  58         SIVAL(req->out.body,    0x04,   io->smb2.out.create_action);
  59         SBVAL(req->out.body,    0x08,   io->smb2.out.create_time);
  60         SBVAL(req->out.body,    0x10,   io->smb2.out.access_time);
  61         SBVAL(req->out.body,    0x18,   io->smb2.out.write_time);
  62         SBVAL(req->out.body,    0x20,   io->smb2.out.change_time);
  63         SBVAL(req->out.body,    0x28,   io->smb2.out.alloc_size);
  64         SBVAL(req->out.body,    0x30,   io->smb2.out.size);
  65         SIVAL(req->out.body,    0x38,   io->smb2.out.file_attr);
  66         SIVAL(req->out.body,    0x3C,   io->smb2.out.reserved2);
  67         smb2srv_push_handle(req->out.body, 0x40, io->smb2.out.file.ntvfs);
  68         SMB2SRV_CHECK(smb2_push_o32s32_blob(&req->out, 0x50, blob));
  69
  70         /* also setup the chained file handle */
  71         req->chained_file_handle = req->_chained_file_handle;
  72         smb2srv_push_handle(req->chained_file_handle, 0, io->smb2.out.file.ntvfs);
  73
  74         smb2srv_send_reply(req);
  75 }
  76
  77 void smb2srv_create_recv(struct smb2srv_request *req)
  78 {
  79         union smb_open *io;
  80         DATA_BLOB blob;
  81         int i;
  82
  83         SMB2SRV_CHECK_BODY_SIZE(req, 0x38, true);
  84         SMB2SRV_TALLOC_IO_PTR(io, union smb_open);
  85         SMB2SRV_SETUP_NTVFS_REQUEST(smb2srv_create_send, NTVFS_ASYNC_STATE_MAY_ASYNC);
  86
  87         ZERO_STRUCT(io->smb2.in);
  88         io->smb2.level                  = RAW_OPEN_SMB2;
  89         io->smb2.in.security_flags      = CVAL(req->in.body, 0x02);
  90         io->smb2.in.oplock_level        = CVAL(req->in.body, 0x03);
  91         io->smb2.in.impersonation_level = IVAL(req->in.body, 0x04);
  92         io->smb2.in.create_flags        = BVAL(req->in.body, 0x08);
  93         io->smb2.in.reserved            = BVAL(req->in.body, 0x10);
  94         io->smb2.in.desired_access      = IVAL(req->in.body, 0x18);
  95         io->smb2.in.file_attributes     = IVAL(req->in.body, 0x1C);
  96         io->smb2.in.share_access        = IVAL(req->in.body, 0x20);
  97         io->smb2.in.create_disposition  = IVAL(req->in.body, 0x24);
  98         io->smb2.in.create_options      = IVAL(req->in.body, 0x28);
  99         SMB2SRV_CHECK(smb2_pull_o16s16_string(&req->in, io, req->in.body+0x2C, &io->smb2.in.fname));
 100         SMB2SRV_CHECK(smb2_pull_o32s32_blob(&req->in, io, req->in.body+0x30, &blob));
 101         SMB2SRV_CHECK(smb2_create_blob_parse(io, blob, &io->smb2.in.blobs));
 102
 103         /* interpret the parsed tags that a server needs to respond to */
 104         for (i=0;i<io->smb2.in.blobs.num_blobs;i++) {
 105                 if (strcmp(io->smb2.in.blobs.blobs[i].tag, SMB2_CREATE_TAG_EXTA) == 0) {
 106                         SMB2SRV_CHECK(ea_pull_list_chained(&io->smb2.in.blobs.blobs[i].data, io,
 107                                                            &io->smb2.in.eas.num_eas,
 108                                                            &io->smb2.in.eas.eas));
 109                 }
 110                 if (strcmp(io->smb2.in.blobs.blobs[i].tag, SMB2_CREATE_TAG_SECD) == 0) {
 111                         enum ndr_err_code ndr_err;
 112                         io->smb2.in.sec_desc = talloc(io, struct security_descriptor);
 113                         if (io->smb2.in.sec_desc == NULL) {
 114                                 smb2srv_send_error(req,  NT_STATUS_NO_MEMORY);
 115                                 return;
 116                         }
 117                         ndr_err = ndr_pull_struct_blob(&io->smb2.in.blobs.blobs[i].data, io,
 118                                                        io->smb2.in.sec_desc,
 119                                                        (ndr_pull_flags_fn_t)ndr_pull_security_descriptor);
 120                         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 121                                 smb2srv_send_error(req,  ndr_map_error2ntstatus(ndr_err));
 122                                 return;
 123                         }
 124                 }
 125                 if (strcmp(io->smb2.in.blobs.blobs[i].tag, SMB2_CREATE_TAG_DHNQ) == 0) {
 126                         io->smb2.in.durable_open = true;
 127                 }
 128                 if (strcmp(io->smb2.in.blobs.blobs[i].tag, SMB2_CREATE_TAG_DHNC) == 0) {
 129                         if (io->smb2.in.blobs.blobs[i].data.length != 16) {
 130                                 smb2srv_send_error(req,  NT_STATUS_INVALID_PARAMETER);
 131                                 return;
 132                         }
 133                         io->smb2.in.durable_handle = talloc(io, struct smb2_handle);
 134                         if (io->smb2.in.durable_handle == NULL) {
 135                                 smb2srv_send_error(req,  NT_STATUS_NO_MEMORY);
 136                                 return;
 137                         }
 138                         smb2_pull_handle(io->smb2.in.blobs.blobs[i].data.data, io->smb2.in.durable_handle);
 139                 }
 140                 if (strcmp(io->smb2.in.blobs.blobs[i].tag, SMB2_CREATE_TAG_ALSI) == 0) {
 141                         if (io->smb2.in.blobs.blobs[i].data.length != 8) {
 142                                 smb2srv_send_error(req,  NT_STATUS_INVALID_PARAMETER);
 143                                 return;
 144                         }
 145                         io->smb2.in.alloc_size = BVAL(io->smb2.in.blobs.blobs[i].data.data, 0);
 146                 }
 147                 if (strcmp(io->smb2.in.blobs.blobs[i].tag, SMB2_CREATE_TAG_MXAC) == 0) {
 148                         io->smb2.in.query_maximal_access = true;
 149                 }
 150                 if (strcmp(io->smb2.in.blobs.blobs[i].tag, SMB2_CREATE_TAG_TWRP) == 0) {
 151                         if (io->smb2.in.blobs.blobs[i].data.length != 8) {
 152                                 smb2srv_send_error(req,  NT_STATUS_INVALID_PARAMETER);
 153                                 return;
 154                         }
 155                         io->smb2.in.timewarp = BVAL(io->smb2.in.blobs.blobs[i].data.data, 0);
 156                 }
 157                 if (strcmp(io->smb2.in.blobs.blobs[i].tag, SMB2_CREATE_TAG_QFID) == 0) {
 158                         io->smb2.in.query_on_disk_id = true;
 159                 }
 160         }
 161
 162         /* the VFS backend does not yet handle NULL filenames */
 163         if (io->smb2.in.fname == NULL) {
 164                 io->smb2.in.fname = "";
 165         }
 166
 167         SMB2SRV_CALL_NTVFS_BACKEND(ntvfs_open(req->ntvfs, io));
 168 }
 169
 170 static void smb2srv_close_send(struct ntvfs_request *ntvfs)
 171 {
 172         struct smb2srv_request *req;
 173         union smb_close *io;
 174
 175         SMB2SRV_CHECK_ASYNC_STATUS(io, union smb_close);
 176         SMB2SRV_CHECK(smb2srv_setup_reply(req, 0x3C, false, 0));
 177
 178         SSVAL(req->out.body,    0x02,   io->smb2.out.flags);
 179         SIVAL(req->out.body,    0x04,   io->smb2.out._pad);
 180         SBVAL(req->out.body,    0x08,   io->smb2.out.create_time);
 181         SBVAL(req->out.body,    0x10,   io->smb2.out.access_time);
 182         SBVAL(req->out.body,    0x18,   io->smb2.out.write_time);
 183         SBVAL(req->out.body,    0x20,   io->smb2.out.change_time);
 184         SBVAL(req->out.body,    0x28,   io->smb2.out.alloc_size);
 185         SBVAL(req->out.body,    0x30,   io->smb2.out.size);
 186         SIVAL(req->out.body,    0x38,   io->smb2.out.file_attr);
 187
 188         /* also destroy the chained file handle */
 189         req->chained_file_handle = NULL;
 190         memset(req->_chained_file_handle, 0, sizeof(req->_chained_file_handle));
 191
 192         smb2srv_send_reply(req);
 193 }
 194
 195 void smb2srv_close_recv(struct smb2srv_request *req)
 196 {
 197         union smb_close *io;
 198
 199         SMB2SRV_CHECK_BODY_SIZE(req, 0x18, false);
 200         SMB2SRV_TALLOC_IO_PTR(io, union smb_close);
 201         SMB2SRV_SETUP_NTVFS_REQUEST(smb2srv_close_send, NTVFS_ASYNC_STATE_MAY_ASYNC);
 202
 203         io->smb2.level                  = RAW_CLOSE_SMB2;
 204         io->smb2.in.flags               = SVAL(req->in.body, 0x02);
 205         io->smb2.in._pad                = IVAL(req->in.body, 0x04);
 206         io->smb2.in.file.ntvfs          = smb2srv_pull_handle(req, req->in.body, 0x08);
 207
 208         SMB2SRV_CHECK_FILE_HANDLE(io->smb2.in.file.ntvfs);
 209         SMB2SRV_CALL_NTVFS_BACKEND(ntvfs_close(req->ntvfs, io));
 210 }
 211
 212 static void smb2srv_flush_send(struct ntvfs_request *ntvfs)
 213 {
 214         struct smb2srv_request *req;
 215         union smb_flush *io;
 216
 217         SMB2SRV_CHECK_ASYNC_STATUS(io, union smb_flush);
 218         SMB2SRV_CHECK(smb2srv_setup_reply(req, 0x04, false, 0));
 219
 220         SSVAL(req->out.body,    0x02,   io->smb2.out.reserved);
 221
 222         smb2srv_send_reply(req);
 223 }
 224
 225 void smb2srv_flush_recv(struct smb2srv_request *req)
 226 {
 227         union smb_flush *io;
 228
 229         SMB2SRV_CHECK_BODY_SIZE(req, 0x18, false);
 230         SMB2SRV_TALLOC_IO_PTR(io, union smb_flush);
 231         SMB2SRV_SETUP_NTVFS_REQUEST(smb2srv_flush_send, NTVFS_ASYNC_STATE_MAY_ASYNC);
 232
 233         io->smb2.level                  = RAW_FLUSH_SMB2;
 234         io->smb2.in.reserved1           = SVAL(req->in.body, 0x02);
 235         io->smb2.in.reserved2           = IVAL(req->in.body, 0x04);
 236         io->smb2.in.file.ntvfs          = smb2srv_pull_handle(req, req->in.body, 0x08);
 237
 238         SMB2SRV_CHECK_FILE_HANDLE(io->smb2.in.file.ntvfs);
 239         SMB2SRV_CALL_NTVFS_BACKEND(ntvfs_flush(req->ntvfs, io));
 240 }
 241
 242 static void smb2srv_read_send(struct ntvfs_request *ntvfs)
 243 {
 244         struct smb2srv_request *req;
 245         union smb_read *io;
 246
 247         SMB2SRV_CHECK_ASYNC_STATUS(io, union smb_read);
 248         SMB2SRV_CHECK(smb2srv_setup_reply(req, 0x10, true, io->smb2.out.data.length));
 249
 250         /* TODO: avoid the memcpy */
 251         SMB2SRV_CHECK(smb2_push_o16s32_blob(&req->out, 0x02, io->smb2.out.data));
 252         SIVAL(req->out.body,    0x08,   io->smb2.out.remaining);
 253         SIVAL(req->out.body,    0x0C,   io->smb2.out.reserved);
 254
 255         smb2srv_send_reply(req);
 256 }
 257
 258 void smb2srv_read_recv(struct smb2srv_request *req)
 259 {
 260         union smb_read *io;
 261
 262         SMB2SRV_CHECK_BODY_SIZE(req, 0x30, true);
 263
 264         /* MS-SMB2 2.2.19 read must have a single byte of zero */
 265         if (req->in.body_size - req->in.body_fixed < 1) {
 266                 smb2srv_send_error(req,  NT_STATUS_INVALID_PARAMETER);
 267                 return;
 268         }
 269         SMB2SRV_TALLOC_IO_PTR(io, union smb_read);
 270         SMB2SRV_SETUP_NTVFS_REQUEST(smb2srv_read_send, NTVFS_ASYNC_STATE_MAY_ASYNC);
 271
 272         io->smb2.level                  = RAW_READ_SMB2;
 273         io->smb2.in._pad                = SVAL(req->in.body, 0x02);
 274         io->smb2.in.length              = IVAL(req->in.body, 0x04);
 275         io->smb2.in.offset              = BVAL(req->in.body, 0x08);
 276         io->smb2.in.file.ntvfs          = smb2srv_pull_handle(req, req->in.body, 0x10);
 277         io->smb2.in.min_count           = IVAL(req->in.body, 0x20);
 278         io->smb2.in.channel             = IVAL(req->in.body, 0x24);
 279         io->smb2.in.remaining           = IVAL(req->in.body, 0x28);
 280         io->smb2.in.channel_offset      = SVAL(req->in.body, 0x2C);
 281         io->smb2.in.channel_length      = SVAL(req->in.body, 0x2E);
 282
 283         SMB2SRV_CHECK_FILE_HANDLE(io->smb2.in.file.ntvfs);
 284
 285         /* preallocate the buffer for the backends */
 286         io->smb2.out.data = data_blob_talloc(io, NULL, io->smb2.in.length);
 287         if (io->smb2.out.data.length != io->smb2.in.length) {
 288                 SMB2SRV_CHECK(NT_STATUS_NO_MEMORY);
 289         }
 290
 291         SMB2SRV_CALL_NTVFS_BACKEND(ntvfs_read(req->ntvfs, io));
 292 }
 293
 294 static void smb2srv_write_send(struct ntvfs_request *ntvfs)
 295 {
 296         struct smb2srv_request *req;
 297         union smb_write *io;
 298
 299         SMB2SRV_CHECK_ASYNC_STATUS(io, union smb_write);
 300         SMB2SRV_CHECK(smb2srv_setup_reply(req, 0x10, true, 0));
 301
 302         SSVAL(req->out.body,    0x02,   io->smb2.out._pad);
 303         SIVAL(req->out.body,    0x04,   io->smb2.out.nwritten);
 304         SBVAL(req->out.body,    0x08,   io->smb2.out.unknown1);
 305
 306         smb2srv_send_reply(req);
 307 }
 308
 309 void smb2srv_write_recv(struct smb2srv_request *req)
 310 {
 311         union smb_write *io;
 312
 313         SMB2SRV_CHECK_BODY_SIZE(req, 0x30, true);
 314         SMB2SRV_TALLOC_IO_PTR(io, union smb_write);
 315         SMB2SRV_SETUP_NTVFS_REQUEST(smb2srv_write_send, NTVFS_ASYNC_STATE_MAY_ASYNC);
 316
 317         /* TODO: avoid the memcpy */
 318         io->smb2.level                  = RAW_WRITE_SMB2;
 319         SMB2SRV_CHECK(smb2_pull_o16s32_blob(&req->in, io, req->in.body+0x02, &io->smb2.in.data));
 320         io->smb2.in.offset              = BVAL(req->in.body, 0x08);
 321         io->smb2.in.file.ntvfs          = smb2srv_pull_handle(req, req->in.body, 0x10);
 322         io->smb2.in.unknown1            = BVAL(req->in.body, 0x20);
 323         io->smb2.in.unknown2            = BVAL(req->in.body, 0x28);
 324
 325         SMB2SRV_CHECK_FILE_HANDLE(io->smb2.in.file.ntvfs);
 326         SMB2SRV_CALL_NTVFS_BACKEND(ntvfs_write(req->ntvfs, io));
 327 }
 328
 329 static void smb2srv_lock_send(struct ntvfs_request *ntvfs)
 330 {
 331         struct smb2srv_request *req;
 332         union smb_lock *io;
 333
 334         SMB2SRV_CHECK_ASYNC_STATUS_ERR(io, union smb_lock);
 335         SMB2SRV_CHECK(smb2srv_setup_reply(req, 0x04, false, 0));
 336
 337         SSVAL(req->out.body,    0x02,   io->smb2.out.reserved);
 338
 339         smb2srv_send_reply(req);
 340 }
 341
 342 void smb2srv_lock_recv(struct smb2srv_request *req)
 343 {
 344         union smb_lock *io;
 345         int i;
 346
 347         SMB2SRV_CHECK_BODY_SIZE(req, 0x30, false);
 348         SMB2SRV_TALLOC_IO_PTR(io, union smb_lock);
 349         SMB2SRV_SETUP_NTVFS_REQUEST(smb2srv_lock_send, NTVFS_ASYNC_STATE_MAY_ASYNC);
 350
 351         io->smb2.level                  = RAW_LOCK_SMB2;
 352         io->smb2.in.lock_count          = SVAL(req->in.body, 0x02);
 353         io->smb2.in.lock_sequence       = IVAL(req->in.body, 0x04);
 354         io->smb2.in.file.ntvfs          = smb2srv_pull_handle(req, req->in.body, 0x08);
 355         if (req->in.body_size < 24 + 24*(uint64_t)io->smb2.in.lock_count) {
 356                 DEBUG(0,("%s: lock buffer too small\n", __location__));
 357                 smb2srv_send_error(req,  NT_STATUS_FOOBAR);
 358                 return;
 359         }
 360         io->smb2.in.locks = talloc_array(io, struct smb2_lock_element,
 361                                          io->smb2.in.lock_count);
 362         if (io->smb2.in.locks == NULL) {
 363                 smb2srv_send_error(req, NT_STATUS_NO_MEMORY);
 364                 return;
 365         }
 366
 367         for (i=0;i<io->smb2.in.lock_count;i++) {
 368                 io->smb2.in.locks[i].offset     = BVAL(req->in.body, 24 + i*24);
 369                 io->smb2.in.locks[i].length     = BVAL(req->in.body, 32 + i*24);
 370                 io->smb2.in.locks[i].flags      = IVAL(req->in.body, 40 + i*24);
 371                 io->smb2.in.locks[i].reserved   = IVAL(req->in.body, 44 + i*24);
 372         }
 373
 374         SMB2SRV_CHECK_FILE_HANDLE(io->smb2.in.file.ntvfs);
 375         SMB2SRV_CALL_NTVFS_BACKEND(ntvfs_lock(req->ntvfs, io));
 376 }
 377
 378 static void smb2srv_ioctl_send(struct ntvfs_request *ntvfs)
 379 {
 380         struct smb2srv_request *req;
 381         union smb_ioctl *io;
 382
 383         SMB2SRV_CHECK_ASYNC_STATUS_ERR(io, union smb_ioctl);
 384         SMB2SRV_CHECK(smb2srv_setup_reply(req, 0x30, true, 0));
 385
 386         SSVAL(req->out.body,    0x02,   io->smb2.out.reserved);
 387         SIVAL(req->out.body,    0x04,   io->smb2.out.function);
 388         if (io->smb2.level == RAW_IOCTL_SMB2_NO_HANDLE) {
 389                 struct smb2_handle h;
 390                 h.data[0] = UINT64_MAX;
 391                 h.data[1] = UINT64_MAX;
 392                 smb2_push_handle(req->out.body + 0x08, &h);
 393         } else {
 394                 smb2srv_push_handle(req->out.body, 0x08,io->smb2.in.file.ntvfs);
 395         }
 396         SMB2SRV_CHECK(smb2_push_o32s32_blob(&req->out, 0x18, io->smb2.out.in));
 397         SMB2SRV_CHECK(smb2_push_o32s32_blob(&req->out, 0x20, io->smb2.out.out));
 398         SIVAL(req->out.body,    0x28,   io->smb2.out.flags);
 399         SIVAL(req->out.body,    0x2C,   io->smb2.out.reserved2);
 400
 401         smb2srv_send_reply(req);
 402 }
 403
 404 void smb2srv_ioctl_recv(struct smb2srv_request *req)
 405 {
 406         union smb_ioctl *io;
 407         struct smb2_handle h;
 408
 409         SMB2SRV_CHECK_BODY_SIZE(req, 0x38, true);
 410         SMB2SRV_TALLOC_IO_PTR(io, union smb_ioctl);
 411         SMB2SRV_SETUP_NTVFS_REQUEST(smb2srv_ioctl_send, NTVFS_ASYNC_STATE_MAY_ASYNC);
 412
 413         /* TODO: avoid the memcpy */
 414         io->smb2.in.reserved            = SVAL(req->in.body, 0x02);
 415         io->smb2.in.function            = IVAL(req->in.body, 0x04);
 416         /* file handle ... */
 417         SMB2SRV_CHECK(smb2_pull_o32s32_blob(&req->in, io, req->in.body+0x18, &io->smb2.in.out));
 418         io->smb2.in.max_input_response  = IVAL(req->in.body, 0x20);
 419         SMB2SRV_CHECK(smb2_pull_o32s32_blob(&req->in, io, req->in.body+0x24, &io->smb2.in.in));
 420         io->smb2.in.max_output_response = IVAL(req->in.body, 0x2C);
 421         io->smb2.in.flags               = IVAL(req->in.body, 0x30);
 422         io->smb2.in.reserved2           = IVAL(req->in.body, 0x34);
 423
 424         smb2_pull_handle(req->in.body + 0x08, &h);
 425         if (h.data[0] == UINT64_MAX && h.data[1] == UINT64_MAX) {
 426                 io->smb2.level          = RAW_IOCTL_SMB2_NO_HANDLE;
 427         } else {
 428                 io->smb2.level          = RAW_IOCTL_SMB2;
 429                 io->smb2.in.file.ntvfs  = smb2srv_pull_handle(req, req->in.body, 0x08);
 430                 SMB2SRV_CHECK_FILE_HANDLE(io->smb2.in.file.ntvfs);
 431         }
 432
 433         SMB2SRV_CALL_NTVFS_BACKEND(ntvfs_ioctl(req->ntvfs, io));
 434 }
 435
 436 static void smb2srv_notify_send(struct ntvfs_request *ntvfs)
 437 {
 438         struct smb2srv_request *req;
 439         union smb_notify *io;
 440         size_t size = 0;
 441         int i;
 442         uint8_t *p;
 443         DATA_BLOB blob = data_blob(NULL, 0);
 444
 445         SMB2SRV_CHECK_ASYNC_STATUS(io, union smb_notify);
 446         SMB2SRV_CHECK(smb2srv_setup_reply(req, 0x08, true, 0));
 447
 448 #define MAX_BYTES_PER_CHAR 3
 449
 450         /* work out how big the reply buffer could be */
 451         for (i=0;i<io->smb2.out.num_changes;i++) {
 452                 size += 12 + 3 + (1+strlen(io->smb2.out.changes[i].name.s)) * MAX_BYTES_PER_CHAR;
 453         }
 454
 455         blob = data_blob_talloc(req, NULL, size);
 456         if (size > 0 && !blob.data) {
 457                 SMB2SRV_CHECK(NT_STATUS_NO_MEMORY);
 458         }
 459
 460         p = blob.data;
 461
 462         /* construct the changes buffer */
 463         for (i=0;i<io->smb2.out.num_changes;i++) {
 464                 uint32_t ofs;
 465                 ssize_t len;
 466
 467                 SIVAL(p, 4, io->smb2.out.changes[i].action);
 468                 len = push_string(p + 12, io->smb2.out.changes[i].name.s,
 469                                   blob.length - (p+12 - blob.data), STR_UNICODE);
 470                 SIVAL(p, 8, len);
 471
 472                 ofs = len + 12;
 473
 474                 if (ofs & 3) {
 475                         int pad = 4 - (ofs & 3);
 476                         memset(p+ofs, 0, pad);
 477                         ofs += pad;
 478                 }
 479
 480                 if (i == io->smb2.out.num_changes-1) {
 481                         SIVAL(p, 0, 0);
 482                 } else {
 483                         SIVAL(p, 0, ofs);
 484                 }
 485
 486                 p += ofs;
 487         }
 488
 489         blob.length = p - blob.data;
 490
 491         SMB2SRV_CHECK(smb2_push_o16s32_blob(&req->out, 0x02, blob));
 492
 493         smb2srv_send_reply(req);
 494 }
 495
 496 void smb2srv_notify_recv(struct smb2srv_request *req)
 497 {
 498         union smb_notify *io;
 499
 500         SMB2SRV_CHECK_BODY_SIZE(req, 0x20, false);
 501         SMB2SRV_TALLOC_IO_PTR(io, union smb_notify);
 502         SMB2SRV_SETUP_NTVFS_REQUEST(smb2srv_notify_send, NTVFS_ASYNC_STATE_MAY_ASYNC);
 503
 504         io->smb2.level                  = RAW_NOTIFY_SMB2;
 505         io->smb2.in.recursive           = SVAL(req->in.body, 0x02);
 506         io->smb2.in.buffer_size         = IVAL(req->in.body, 0x04);
 507         io->smb2.in.file.ntvfs          = smb2srv_pull_handle(req, req->in.body, 0x08);
 508         io->smb2.in.completion_filter   = IVAL(req->in.body, 0x18);
 509         io->smb2.in.unknown             = BVAL(req->in.body, 0x1C);
 510
 511         SMB2SRV_CHECK_FILE_HANDLE(io->smb2.in.file.ntvfs);
 512         SMB2SRV_CALL_NTVFS_BACKEND(ntvfs_notify(req->ntvfs, io));
 513 }
 514
 515 static void smb2srv_break_send(struct ntvfs_request *ntvfs)
 516 {
 517         struct smb2srv_request *req;
 518         union smb_lock *io;
 519
 520         SMB2SRV_CHECK_ASYNC_STATUS_ERR(io, union smb_lock);
 521         SMB2SRV_CHECK(smb2srv_setup_reply(req, 0x18, false, 0));
 522
 523         SCVAL(req->out.body,    0x02,   io->smb2_break.out.oplock_level);
 524         SCVAL(req->out.body,    0x03,   io->smb2_break.out.reserved);
 525         SIVAL(req->out.body,    0x04,   io->smb2_break.out.reserved2);
 526         smb2srv_push_handle(req->out.body, 0x08,io->smb2_break.out.file.ntvfs);
 527
 528         smb2srv_send_reply(req);
 529 }
 530
 531 void smb2srv_break_recv(struct smb2srv_request *req)
 532 {
 533         union smb_lock *io;
 534
 535         SMB2SRV_CHECK_BODY_SIZE(req, 0x18, false);
 536         SMB2SRV_TALLOC_IO_PTR(io, union smb_lock);
 537         SMB2SRV_SETUP_NTVFS_REQUEST(smb2srv_break_send, NTVFS_ASYNC_STATE_MAY_ASYNC);
 538
 539         io->smb2_break.level            = RAW_LOCK_SMB2_BREAK;
 540         io->smb2_break.in.oplock_level  = CVAL(req->in.body, 0x02);
 541         io->smb2_break.in.reserved      = CVAL(req->in.body, 0x03);
 542         io->smb2_break.in.reserved2     = IVAL(req->in.body, 0x04);
 543         io->smb2_break.in.file.ntvfs    = smb2srv_pull_handle(req, req->in.body, 0x08);
 544
 545         SMB2SRV_CHECK_FILE_HANDLE(io->smb2_break.in.file.ntvfs);
 546         SMB2SRV_CALL_NTVFS_BACKEND(ntvfs_lock(req->ntvfs, io));
 547 }