source4/torture/smb2/ioctl.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    test suite for SMB2 ioctl operations
   5
   6    Copyright (C) David Disseldorp 2011
   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 "librpc/gen_ndr/security.h"
  24 #include "libcli/smb2/smb2.h"
  25 #include "libcli/smb2/smb2_calls.h"
  26 #include "torture/torture.h"
  27 #include "torture/smb2/proto.h"
  28 #include "librpc/gen_ndr/ndr_ioctl.h"
  29
  30 #define FNAME   "testfsctl.dat"
  31 #define FNAME2  "testfsctl2.dat"
  32
  33 /*
  34    basic testing of SMB2 shadow copy calls
  35 */
  36 static bool test_ioctl_get_shadow_copy(struct torture_context *torture,
  37                                        struct smb2_tree *tree)
  38 {
  39         struct smb2_handle h;
  40         uint8_t buf[100];
  41         NTSTATUS status;
  42         union smb_ioctl ioctl;
  43         TALLOC_CTX *tmp_ctx = talloc_new(tree);
  44
  45         smb2_util_unlink(tree, FNAME);
  46
  47         status = torture_smb2_testfile(tree, FNAME, &h);
  48         if (!NT_STATUS_IS_OK(status)) {
  49                 printf("create write\n");
  50                 return false;
  51         }
  52
  53         ZERO_ARRAY(buf);
  54         status = smb2_util_write(tree, h, buf, 0, ARRAY_SIZE(buf));
  55         if (!NT_STATUS_IS_OK(status)) {
  56                 printf("failed write\n");
  57                 return false;
  58         }
  59
  60         ZERO_STRUCT(ioctl);
  61         ioctl.smb2.level = RAW_IOCTL_SMB2;
  62         ioctl.smb2.in.file.handle = h;
  63         ioctl.smb2.in.function = FSCTL_SRV_ENUM_SNAPS;
  64         ioctl.smb2.in.max_response_size = 16;
  65         ioctl.smb2.in.flags = SMB2_IOCTL_FLAG_IS_FSCTL;
  66
  67         status = smb2_ioctl(tree, tmp_ctx, &ioctl.smb2);
  68         if (!NT_STATUS_IS_OK(status)) {
  69                 printf("FSCTL_SRV_ENUM_SNAPS failed\n");
  70                 return false;
  71         }
  72
  73         return true;
  74 }
  75
  76 /*
  77    basic testing of the SMB2 server side copy ioctls
  78 */
  79 static bool test_ioctl_req_resume_key(struct torture_context *torture,
  80                                       struct smb2_tree *tree)
  81 {
  82         struct smb2_handle h;
  83         uint8_t buf[100];
  84         NTSTATUS status;
  85         union smb_ioctl ioctl;
  86         TALLOC_CTX *tmp_ctx = talloc_new(tree);
  87         struct req_resume_key_rsp res_key;
  88         enum ndr_err_code ndr_ret;
  89
  90         smb2_util_unlink(tree, FNAME);
  91
  92         status = torture_smb2_testfile(tree, FNAME, &h);
  93         if (!NT_STATUS_IS_OK(status)) {
  94                 printf("create write\n");
  95                 return false;
  96         }
  97
  98         ZERO_ARRAY(buf);
  99         status = smb2_util_write(tree, h, buf, 0, ARRAY_SIZE(buf));
 100         if (!NT_STATUS_IS_OK(status)) {
 101                 printf("failed write\n");
 102                 return false;
 103         }
 104
 105         ZERO_STRUCT(ioctl);
 106         ioctl.smb2.level = RAW_IOCTL_SMB2;
 107         ioctl.smb2.in.file.handle = h;
 108         ioctl.smb2.in.function = FSCTL_SRV_REQUEST_RESUME_KEY;
 109         ioctl.smb2.in.max_response_size = 32;
 110         ioctl.smb2.in.flags = SMB2_IOCTL_FLAG_IS_FSCTL;
 111
 112         status = smb2_ioctl(tree, tmp_ctx, &ioctl.smb2);
 113         if (!NT_STATUS_IS_OK(status)) {
 114                 printf("FSCTL_SRV_REQUEST_RESUME_KEY failed\n");
 115                 return false;
 116         }
 117
 118         ndr_ret = ndr_pull_struct_blob(&ioctl.smb2.out.out, tmp_ctx, &res_key,
 119                         (ndr_pull_flags_fn_t)ndr_pull_req_resume_key_rsp);
 120         if (ndr_ret != NDR_ERR_SUCCESS) {
 121                 return false;
 122         }
 123
 124         ndr_print_debug((ndr_print_fn_t)ndr_print_req_resume_key_rsp, "yo", &res_key);
 125
 126         talloc_free(tmp_ctx);
 127         return true;
 128 }
 129
 130 static bool test_setup_copy_chunk(struct smb2_tree *tree, TALLOC_CTX *mem_ctx,
 131                                   uint32_t nchunks,
 132                                   struct smb2_handle *src_h,
 133                                   uint64_t src_size,
 134                                   struct smb2_handle *dest_h,
 135                                   uint64_t dest_size,
 136                                   struct srv_copychunk_copy *cc_copy,
 137                                   union smb_ioctl *ioctl)
 138 {
 139         struct req_resume_key_rsp res_key;
 140         NTSTATUS status;
 141         enum ndr_err_code ndr_ret;
 142         uint8_t *buf = talloc_zero_size(mem_ctx, MAX(src_size, dest_size));
 143         if (buf == NULL) {
 144                 printf("no mem for file data buffer\n");
 145                 return false;
 146         }
 147
 148         smb2_util_unlink(tree, FNAME);
 149         smb2_util_unlink(tree, FNAME2);
 150
 151         status = torture_smb2_testfile(tree, FNAME, src_h);
 152         if (!NT_STATUS_IS_OK(status)) {
 153                 printf("create write\n");
 154                 return false;
 155         }
 156
 157         if (src_size > 0) {
 158                 status = smb2_util_write(tree, *src_h, buf, 0, src_size);
 159                 if (!NT_STATUS_IS_OK(status)) {
 160                         printf("failed src write\n");
 161                         return false;
 162                 }
 163         }
 164
 165         status = torture_smb2_testfile(tree, FNAME2, dest_h);
 166         if (!NT_STATUS_IS_OK(status)) {
 167                 printf("create write\n");
 168                 return false;
 169         }
 170
 171         if (dest_size > 0) {
 172                 status = smb2_util_write(tree, *dest_h, buf, 0, dest_size);
 173                 if (!NT_STATUS_IS_OK(status)) {
 174                         printf("failed dest write\n");
 175                         return false;
 176                 }
 177         }
 178
 179         ZERO_STRUCTPN(ioctl);
 180         ioctl->smb2.level = RAW_IOCTL_SMB2;
 181         ioctl->smb2.in.file.handle = *src_h;
 182         ioctl->smb2.in.function = FSCTL_SRV_REQUEST_RESUME_KEY;
 183         /* Allow for Key + ContextLength + Context */
 184         ioctl->smb2.in.max_response_size = 32;
 185         ioctl->smb2.in.flags = SMB2_IOCTL_FLAG_IS_FSCTL;
 186
 187         status = smb2_ioctl(tree, mem_ctx, &ioctl->smb2);
 188         if (!NT_STATUS_IS_OK(status)) {
 189                 printf("FSCTL_SRV_REQUEST_RESUME_KEY failed\n");
 190                 return false;
 191         }
 192
 193         ndr_ret = ndr_pull_struct_blob(&ioctl->smb2.out.out, mem_ctx, &res_key,
 194                         (ndr_pull_flags_fn_t)ndr_pull_req_resume_key_rsp);
 195         if (ndr_ret != NDR_ERR_SUCCESS) {
 196                 return false;
 197         }
 198
 199         ZERO_STRUCTPN(ioctl);
 200         ioctl->smb2.level = RAW_IOCTL_SMB2;
 201         ioctl->smb2.in.file.handle = *dest_h;
 202         ioctl->smb2.in.function = FSCTL_SRV_COPYCHUNK;
 203         ioctl->smb2.in.max_response_size = sizeof(struct srv_copychunk_rsp);
 204         ioctl->smb2.in.flags = SMB2_IOCTL_FLAG_IS_FSCTL;
 205
 206         ZERO_STRUCTPN(cc_copy);
 207         memcpy(cc_copy->source_key, res_key.resume_key, ARRAY_SIZE(cc_copy->source_key));
 208         cc_copy->chunk_count = nchunks;
 209         cc_copy->chunks = talloc_zero_array(mem_ctx, struct srv_copychunk, nchunks);
 210         if (cc_copy->chunks == NULL) {
 211                 printf("not enough memory to allocate %u chunks\n", nchunks);
 212                 return false;
 213         }
 214
 215         return true;
 216 }
 217
 218
 219 static bool check_copy_chunk_rsp(struct srv_copychunk_rsp *cc_rsp,
 220                                  uint32_t ex_chunks_written,
 221                                  uint32_t ex_chunk_bytes_written,
 222                                  uint32_t ex_total_bytes_written)
 223 {
 224         if (cc_rsp->chunks_written != ex_chunks_written) {
 225                 printf("expected %u chunks, got %u\n",
 226                        ex_chunks_written, cc_rsp->chunks_written);
 227                 return false;
 228         }
 229         if (cc_rsp->chunk_bytes_written != ex_chunk_bytes_written) {
 230                 printf("expected %u chunk bytes remaining, got %u\n",
 231                        ex_chunk_bytes_written, cc_rsp->chunk_bytes_written);
 232                 return false;
 233         }
 234         if (cc_rsp->total_bytes_written != ex_total_bytes_written) {
 235                 printf("expected %u total bytes, got %u\n",
 236                        ex_total_bytes_written, cc_rsp->total_bytes_written);
 237                 return false;
 238         }
 239         return true;
 240 }
 241
 242 static bool test_ioctl_copy_chunk(struct torture_context *torture,
 243                                   struct smb2_tree *tree)
 244 {
 245         struct smb2_handle src_h;
 246         struct smb2_handle dest_h;
 247         NTSTATUS status;
 248         union smb_ioctl ioctl;
 249         TALLOC_CTX *tmp_ctx = talloc_new(tree);
 250         struct srv_copychunk_copy cc_copy;
 251         struct srv_copychunk_rsp cc_rsp;
 252         enum ndr_err_code ndr_ret;
 253         bool ok;
 254
 255         ok = test_setup_copy_chunk(tree, tmp_ctx,
 256                                    1, /* 1 chunk */
 257                                    &src_h, 100, /* fill 100 byte src file */
 258                                    &dest_h, 0,  /* 0 byte dest file */
 259                                    &cc_copy,
 260                                    &ioctl);
 261         if (!ok) {
 262                 return false;
 263         }
 264
 265         /* copy all src file data (via a single chunk desc) */
 266         cc_copy.chunks[0].source_off = 0;
 267         cc_copy.chunks[0].target_off = 0;
 268         cc_copy.chunks[0].length = 100;
 269
 270         ndr_ret = ndr_push_struct_blob(&ioctl.smb2.in.out, tmp_ctx,
 271                                        &cc_copy,
 272                         (ndr_push_flags_fn_t)ndr_push_srv_copychunk_copy);
 273         if (ndr_ret != NDR_ERR_SUCCESS) {
 274                 return false;
 275         }
 276
 277         status = smb2_ioctl(tree, tmp_ctx, &ioctl.smb2);
 278         if (!NT_STATUS_IS_OK(status)) {
 279                 printf("FSCTL_SRV_COPYCHUNK failed\n");
 280                 return false;
 281         }
 282
 283         ndr_ret = ndr_pull_struct_blob(&ioctl.smb2.out.out, tmp_ctx,
 284                                        &cc_rsp,
 285                         (ndr_pull_flags_fn_t)ndr_pull_srv_copychunk_rsp);
 286         if (ndr_ret != NDR_ERR_SUCCESS) {
 287                 return false;
 288         }
 289
 290         ok = check_copy_chunk_rsp(&cc_rsp,
 291                                   1,    /* chunks written */
 292                                   0,    /* chunk bytes unsuccessfully written */
 293                                   100); /* total bytes written */
 294         if (!ok) {
 295                 return false;
 296         }
 297
 298         talloc_free(tmp_ctx);
 299         return true;
 300 }
 301
 302 /*
 303    basic testing of SMB2 ioctls
 304 */
 305 struct torture_suite *torture_smb2_ioctl_init(void)
 306 {
 307         struct torture_suite *suite = torture_suite_create(talloc_autofree_context(), "ioctl");
 308
 309         torture_suite_add_1smb2_test(suite, "shadow_copy", test_ioctl_get_shadow_copy);
 310         torture_suite_add_1smb2_test(suite, "req_resume_key", test_ioctl_req_resume_key);
 311         torture_suite_add_1smb2_test(suite, "copy_chunk", test_ioctl_copy_chunk);
 312
 313         suite->description = talloc_strdup(suite, "SMB2-IOCTL tests");
 314
 315         return suite;
 316 }
 317