source4/torture/rpc/fsrvp.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    test suite for File Server Remote VSS Protocol operations
   5
   6    Copyright (C) David Disseldorp 2012-2013
   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 /*
  23  * Windows Server "8" Beta is very picky in how it accepts FSRVP requests, the
  24  * client must be a member of the same AD domain, ndr64 and signing must be
  25  * negotiated for the DCE/RPC bind. E.g.
  26  *
  27  * smbtorture ncacn_np:LUTZE[/pipe/FssagentRpc,smb2,ndr64,sign] \
  28  *            -U 'DOM\user%pw' rpc.fsrvp
  29  *
  30  * This test suite requires a snapshotable share named FSHARE (see #def below).
  31  */
  32 #include "includes.h"
  33 #include "librpc/gen_ndr/security.h"
  34 #include "lib/param/param.h"
  35 #include "libcli/smb2/smb2.h"
  36 #include "libcli/smb2/smb2_calls.h"
  37 #include "libcli/smb_composite/smb_composite.h"
  38 #include "libcli/resolve/resolve.h"
  39 #include "torture/torture.h"
  40 #include "torture/smb2/proto.h"
  41 #include "torture/rpc/torture_rpc.h"
  42 #include "librpc/gen_ndr/ndr_fsrvp.h"
  43 #include "librpc/gen_ndr/ndr_fsrvp_c.h"
  44
  45 #define FSHARE  "fsrvp_share"
  46 #define FNAME   "testfss.dat"
  47
  48 uint8_t fsrvp_magic[] = {0x8a, 0xe3, 0x13, 0x71, 0x02, 0xf4, 0x36, 0x71,
  49                          0x02, 0x40, 0x28, 0x00, 0x3c, 0x65, 0xe0, 0xa8,
  50                          0x44, 0x27, 0x89, 0x43, 0xa6, 0x1d, 0x73, 0x73,
  51                          0xdf, 0x8b, 0x22, 0x92, 0x01, 0x00, 0x00, 0x00,
  52                          0x33, 0x05, 0x71, 0x71, 0xba, 0xbe, 0x37, 0x49,
  53                          0x83, 0x19, 0xb5, 0xdb, 0xef, 0x9c, 0xcc, 0x36,
  54                          0x01, 0x00, 0x00, 0x00};
  55
  56 static bool test_fsrvp_is_path_supported(struct torture_context *tctx,
  57                                          struct dcerpc_pipe *p)
  58 {
  59         struct fss_IsPathSupported r;
  60         struct dcerpc_binding_handle *b = p->binding_handle;
  61         NTSTATUS status;
  62
  63         ZERO_STRUCT(r);
  64         r.in.ShareName = talloc_asprintf(tctx,"\\\\%s\\%s\\",
  65                                          dcerpc_server_name(p),
  66                                          FSHARE);
  67         /* win8 beta sends this */
  68         memcpy(r.in.magic, fsrvp_magic, sizeof(fsrvp_magic));
  69         status = dcerpc_fss_IsPathSupported_r(b, tctx, &r);
  70         torture_assert_ntstatus_ok(tctx, status,
  71                                    "IsPathSupported failed");
  72
  73         ZERO_STRUCT(r);
  74         r.in.ShareName = talloc_asprintf(tctx,"\\\\%s\\%s\\",
  75                                          dcerpc_server_name(p),
  76                                          FSHARE);
  77         /* also works without magic */
  78         status = dcerpc_fss_IsPathSupported_r(b, tctx, &r);
  79         torture_assert_ntstatus_ok(tctx, status,
  80                                    "IsPathSupported failed");
  81
  82         torture_assert(tctx, *r.out.SupportedByThisProvider,
  83                        "path not supported");
  84
  85         torture_comment(tctx, "path %s is supported by fsrvp server %s\n",
  86                         r.in.ShareName, *r.out.OwnerMachineName);
  87
  88         return true;
  89 }
  90
  91 static bool test_fsrvp_get_version(struct torture_context *tctx,
  92                                    struct dcerpc_pipe *p)
  93 {
  94         struct fss_GetSupportedVersion r;
  95         struct dcerpc_binding_handle *b = p->binding_handle;
  96         NTSTATUS status;
  97
  98         ZERO_STRUCT(r);
  99         /* win8 beta sends this */
 100         memcpy(r.in.magic, fsrvp_magic, sizeof(fsrvp_magic));
 101         status = dcerpc_fss_GetSupportedVersion_r(b, tctx, &r);
 102         torture_assert_ntstatus_ok(tctx, status,
 103                                    "GetSupportedVersion failed with magic");
 104
 105         ZERO_STRUCT(r);
 106         /* also works without magic */
 107         status = dcerpc_fss_GetSupportedVersion_r(b, tctx, &r);
 108         torture_assert_ntstatus_ok(tctx, status,
 109                                    "GetSupportedVersion failed without magic");
 110
 111         torture_comment(tctx, "got MinVersion %u\n", *r.out.MinVersion);
 112         torture_comment(tctx, "got MaxVersion %u\n", *r.out.MaxVersion);
 113
 114         return true;
 115 }
 116
 117 static bool test_fsrvp_set_ctx(struct torture_context *tctx,
 118                                struct dcerpc_pipe *p)
 119 {
 120         struct fss_SetContext r;
 121         struct dcerpc_binding_handle *b = p->binding_handle;
 122         NTSTATUS status;
 123
 124         ZERO_STRUCT(r);
 125         r.in.Context = FSRVP_CTX_BACKUP;
 126         status = dcerpc_fss_SetContext_r(b, tctx, &r);
 127         torture_assert_ntstatus_ok(tctx, status, "SetContext failed");
 128
 129         return true;
 130 }
 131
 132 static bool test_fsrvp_sc_create(struct torture_context *tctx,
 133                                  struct dcerpc_pipe *p,
 134                                  const char *share,
 135                                  struct fssagent_share_mapping_1 **sc_map)
 136 {
 137         struct fss_IsPathSupported r_pathsupport_get;
 138         struct fss_GetSupportedVersion r_version_get;
 139         struct fss_SetContext r_context_set;
 140         struct fss_StartShadowCopySet r_scset_start;
 141         struct fss_AddToShadowCopySet r_scset_add1;
 142         struct fss_AddToShadowCopySet r_scset_add2;
 143         struct fss_PrepareShadowCopySet r_scset_prep;
 144         struct fss_CommitShadowCopySet r_scset_commit;
 145         struct fss_ExposeShadowCopySet r_scset_expose;
 146         struct fss_GetShareMapping r_sharemap_get;
 147         struct dcerpc_binding_handle *b = p->binding_handle;
 148         NTSTATUS status;
 149         time_t start_time;
 150         TALLOC_CTX *tmp_ctx = talloc_new(tctx);
 151         struct fssagent_share_mapping_1 *map;
 152
 153         /*
 154          * PrepareShadowCopySet & CommitShadowCopySet often exceed the default
 155          * 60 second dcerpc request timeout against Windows Server "8" Beta.
 156          */
 157         dcerpc_binding_handle_set_timeout(b, 240);
 158
 159         ZERO_STRUCT(r_pathsupport_get); /* sending with zeroed magic */
 160         r_pathsupport_get.in.ShareName = share;
 161         status = dcerpc_fss_IsPathSupported_r(b, tmp_ctx, &r_pathsupport_get);
 162         torture_assert_ntstatus_ok(tctx, status,
 163                                    "IsPathSupported failed");
 164         torture_assert_int_equal(tctx, r_pathsupport_get.out.result, 0,
 165                                  "failed IsPathSupported response");
 166         torture_assert(tctx, r_pathsupport_get.out.SupportedByThisProvider,
 167                        "path not supported");
 168
 169         ZERO_STRUCT(r_version_get);     /* sending with zeroed magic */
 170         status = dcerpc_fss_GetSupportedVersion_r(b, tmp_ctx, &r_version_get);
 171         torture_assert_ntstatus_ok(tctx, status,
 172                                    "GetSupportedVersion failed without magic");
 173         torture_assert_int_equal(tctx, r_version_get.out.result, 0,
 174                                  "failed GetSupportedVersion response");
 175
 176         ZERO_STRUCT(r_context_set);
 177         r_context_set.in.Context = FSRVP_CTX_BACKUP;
 178         status = dcerpc_fss_SetContext_r(b, tmp_ctx, &r_context_set);
 179         torture_assert_ntstatus_ok(tctx, status, "SetContext failed");
 180         torture_assert_int_equal(tctx, r_context_set.out.result, 0,
 181                                  "failed SetContext response");
 182
 183         ZERO_STRUCT(r_scset_start);
 184         r_scset_start.in.ClientShadowCopySetId = GUID_random();
 185         status = dcerpc_fss_StartShadowCopySet_r(b, tmp_ctx, &r_scset_start);
 186         torture_assert_ntstatus_ok(tctx, status,
 187                                    "StartShadowCopySet failed");
 188         torture_assert_int_equal(tctx, r_scset_start.out.result, 0,
 189                                  "failed StartShadowCopySet response");
 190         torture_comment(tctx, "%s: shadow-copy set created\n",
 191                         GUID_string(tmp_ctx, r_scset_start.out.pShadowCopySetId));
 192
 193         ZERO_STRUCT(r_scset_add1);
 194         r_scset_add1.in.ClientShadowCopyId = GUID_random();
 195         r_scset_add1.in.ShadowCopySetId = *r_scset_start.out.pShadowCopySetId;
 196         r_scset_add1.in.ShareName = share;
 197         status = dcerpc_fss_AddToShadowCopySet_r(b, tmp_ctx, &r_scset_add1);
 198         torture_assert_ntstatus_ok(tctx, status,
 199                                    "AddToShadowCopySet failed");
 200         torture_assert_int_equal(tctx, r_scset_add1.out.result, 0,
 201                                  "failed AddToShadowCopySet response");
 202         torture_comment(tctx, "%s(%s): %s added to shadow-copy set\n",
 203                         GUID_string(tmp_ctx, r_scset_start.out.pShadowCopySetId),
 204                         GUID_string(tmp_ctx, r_scset_add1.out.pShadowCopyId),
 205                         r_scset_add1.in.ShareName);
 206
 207         /* attempts to add the same share twice should fail */
 208         ZERO_STRUCT(r_scset_add2);
 209         r_scset_add2.in.ClientShadowCopyId = GUID_random();
 210         r_scset_add2.in.ShadowCopySetId = *r_scset_start.out.pShadowCopySetId;
 211         r_scset_add2.in.ShareName = share;
 212         status = dcerpc_fss_AddToShadowCopySet_r(b, tmp_ctx, &r_scset_add2);
 213         torture_assert_ntstatus_ok(tctx, status,
 214                                    "AddToShadowCopySet failed");
 215         torture_assert_int_equal(tctx, r_scset_add2.out.result,
 216                                  FSRVP_E_OBJECT_ALREADY_EXISTS,
 217                                  "failed AddToShadowCopySet response");
 218
 219         start_time = time_mono(NULL);
 220         ZERO_STRUCT(r_scset_prep);
 221         r_scset_prep.in.ShadowCopySetId = *r_scset_start.out.pShadowCopySetId;
 222 //      r_scset_prep.in.TimeOutInMilliseconds = (1800 * 1000);  /* win8 */
 223         r_scset_prep.in.TimeOutInMilliseconds = (240 * 1000);
 224         status = dcerpc_fss_PrepareShadowCopySet_r(b, tmp_ctx, &r_scset_prep);
 225         torture_assert_ntstatus_ok(tctx, status,
 226                                    "PrepareShadowCopySet failed");
 227         torture_assert_int_equal(tctx, r_scset_prep.out.result, 0,
 228                                  "failed PrepareShadowCopySet response");
 229         torture_comment(tctx, "%s: prepare completed in %llu secs\n",
 230                         GUID_string(tmp_ctx, r_scset_start.out.pShadowCopySetId),
 231                         (unsigned long long)(time_mono(NULL) - start_time));
 232
 233         start_time = time_mono(NULL);
 234         ZERO_STRUCT(r_scset_commit);
 235         r_scset_commit.in.ShadowCopySetId = *r_scset_start.out.pShadowCopySetId;
 236         r_scset_commit.in.TimeOutInMilliseconds = (180 * 1000); /* win8 */
 237         status = dcerpc_fss_CommitShadowCopySet_r(b, tmp_ctx, &r_scset_commit);
 238         torture_assert_ntstatus_ok(tctx, status,
 239                                    "CommitShadowCopySet failed");
 240         torture_assert_int_equal(tctx, r_scset_commit.out.result, 0,
 241                                  "failed CommitShadowCopySet response");
 242         torture_comment(tctx, "%s: commit completed in %llu secs\n",
 243                         GUID_string(tmp_ctx, r_scset_start.out.pShadowCopySetId),
 244                         (unsigned long long)(time_mono(NULL) - start_time));
 245
 246         start_time = time_mono(NULL);
 247         ZERO_STRUCT(r_scset_expose);
 248         r_scset_expose.in.ShadowCopySetId = *r_scset_start.out.pShadowCopySetId;
 249         r_scset_expose.in.TimeOutInMilliseconds = (120 * 1000); /* win8 */
 250         status = dcerpc_fss_ExposeShadowCopySet_r(b, tmp_ctx, &r_scset_expose);
 251         torture_assert_ntstatus_ok(tctx, status,
 252                                    "ExposeShadowCopySet failed");
 253         torture_assert_int_equal(tctx, r_scset_expose.out.result, 0,
 254                                  "failed ExposeShadowCopySet response");
 255         torture_comment(tctx, "%s: expose completed in %llu secs\n",
 256                         GUID_string(tmp_ctx, r_scset_start.out.pShadowCopySetId),
 257                         (unsigned long long)(time_mono(NULL) - start_time));
 258
 259         ZERO_STRUCT(r_sharemap_get);
 260         r_sharemap_get.in.ShadowCopyId = *r_scset_add1.out.pShadowCopyId;
 261         r_sharemap_get.in.ShadowCopySetId = *r_scset_start.out.pShadowCopySetId;
 262         r_sharemap_get.in.ShareName = r_scset_add1.in.ShareName;
 263         r_sharemap_get.in.Level = 1;
 264         status = dcerpc_fss_GetShareMapping_r(b, tmp_ctx, &r_sharemap_get);
 265         torture_assert_ntstatus_ok(tctx, status, "GetShareMapping failed");
 266         torture_assert_int_equal(tctx, r_sharemap_get.out.result, 0,
 267                                  "failed GetShareMapping response");
 268         torture_comment(tctx, "%s(%s): %s is a snapshot of %s at %s\n",
 269                         GUID_string(tmp_ctx, &r_sharemap_get.out.ShareMapping->ShareMapping1->ShadowCopySetId),
 270                         GUID_string(tmp_ctx, &r_sharemap_get.out.ShareMapping->ShareMapping1->ShadowCopyId),
 271                         r_sharemap_get.out.ShareMapping->ShareMapping1->ShadowCopyShareName,
 272                         r_sharemap_get.out.ShareMapping->ShareMapping1->ShareNameUNC,
 273                         nt_time_string(tmp_ctx, r_sharemap_get.out.ShareMapping->ShareMapping1->tstamp));
 274
 275         map = talloc_zero(tctx, struct fssagent_share_mapping_1);
 276         map->ShadowCopySetId = r_sharemap_get.out.ShareMapping->ShareMapping1->ShadowCopySetId;
 277         map->ShadowCopyId = r_sharemap_get.out.ShareMapping->ShareMapping1->ShadowCopyId;
 278         map->ShadowCopyShareName
 279                 = talloc_strdup(tctx, r_sharemap_get.out.ShareMapping->ShareMapping1->ShadowCopyShareName);
 280         map->ShareNameUNC
 281                 = talloc_strdup(tctx, r_sharemap_get.out.ShareMapping->ShareMapping1->ShareNameUNC);
 282         map->tstamp = r_sharemap_get.out.ShareMapping->ShareMapping1->tstamp;
 283
 284         torture_assert(tctx, !GUID_compare(&r_sharemap_get.in.ShadowCopySetId,
 285                                            &map->ShadowCopySetId),
 286                        "sc_set GUID missmatch in GetShareMapping");
 287         torture_assert(tctx, !GUID_compare(&r_sharemap_get.in.ShadowCopyId,
 288                                            &map->ShadowCopyId),
 289                        "sc GUID missmatch in GetShareMapping");
 290
 291         talloc_free(tmp_ctx);
 292         *sc_map = map;
 293
 294         return true;
 295 }
 296
 297 static bool test_fsrvp_sc_delete(struct torture_context *tctx,
 298                                  struct dcerpc_pipe *p,
 299                                  struct fssagent_share_mapping_1 *sc_map)
 300 {
 301         struct dcerpc_binding_handle *b = p->binding_handle;
 302         struct fss_DeleteShareMapping r_sharemap_del;
 303         NTSTATUS status;
 304
 305         ZERO_STRUCT(r_sharemap_del);
 306         r_sharemap_del.in.ShadowCopySetId = sc_map->ShadowCopySetId;
 307         r_sharemap_del.in.ShadowCopyId = sc_map->ShadowCopyId;
 308         r_sharemap_del.in.ShareName = sc_map->ShareNameUNC;
 309         status = dcerpc_fss_DeleteShareMapping_r(b, tctx, &r_sharemap_del);
 310         torture_assert_ntstatus_ok(tctx, status, "DeleteShareMapping failed");
 311         torture_assert_int_equal(tctx, r_sharemap_del.out.result, 0,
 312                                  "failed DeleteShareMapping response");
 313
 314         return true;
 315 }
 316
 317 static bool test_fsrvp_sc_create_simple(struct torture_context *tctx,
 318                                          struct dcerpc_pipe *p)
 319 {
 320         struct fssagent_share_mapping_1 *sc_map;
 321         /* no trailing backslash - should work. See note in cmd_fss.c */
 322         char *share_unc = talloc_asprintf(tctx, "\\\\%s\\%s",
 323                                           dcerpc_server_name(p), FSHARE);
 324
 325         torture_assert(tctx, test_fsrvp_sc_create(tctx, p, share_unc, &sc_map),
 326                        "sc create");
 327
 328         torture_assert(tctx, test_fsrvp_sc_delete(tctx, p, sc_map), "sc del");
 329
 330         return true;
 331 }
 332
 333 static bool test_fsrvp_sc_set_abort(struct torture_context *tctx,
 334                                     struct dcerpc_pipe *p)
 335 {
 336         char *share_unc = talloc_asprintf(tctx, "\\\\%s\\%s\\",
 337                                           dcerpc_server_name(p), FSHARE);
 338         struct dcerpc_binding_handle *b = p->binding_handle;
 339         struct fss_IsPathSupported r_pathsupport_get;
 340         struct fss_GetSupportedVersion r_version_get;
 341         struct fss_SetContext r_context_set;
 342         struct fss_StartShadowCopySet r_scset_start;
 343         struct fss_AbortShadowCopySet r_scset_abort;
 344         struct fss_AddToShadowCopySet r_scset_add;
 345         NTSTATUS status;
 346         TALLOC_CTX *tmp_ctx = talloc_new(tctx);
 347
 348         ZERO_STRUCT(r_pathsupport_get); /* sending with zeroed magic */
 349         r_pathsupport_get.in.ShareName = share_unc;
 350         status = dcerpc_fss_IsPathSupported_r(b, tmp_ctx, &r_pathsupport_get);
 351         torture_assert_ntstatus_ok(tctx, status,
 352                                    "IsPathSupported failed");
 353         torture_assert(tctx, r_pathsupport_get.out.SupportedByThisProvider,
 354                        "path not supported");
 355
 356         ZERO_STRUCT(r_version_get);     /* sending with zeroed magic */
 357         status = dcerpc_fss_GetSupportedVersion_r(b, tmp_ctx, &r_version_get);
 358         torture_assert_ntstatus_ok(tctx, status,
 359                                    "GetSupportedVersion failed without magic");
 360
 361         ZERO_STRUCT(r_context_set);
 362         r_context_set.in.Context = FSRVP_CTX_BACKUP;
 363         status = dcerpc_fss_SetContext_r(b, tmp_ctx, &r_context_set);
 364         torture_assert_ntstatus_ok(tctx, status, "SetContext failed");
 365
 366         ZERO_STRUCT(r_scset_start);
 367         r_scset_start.in.ClientShadowCopySetId = GUID_random();
 368         status = dcerpc_fss_StartShadowCopySet_r(b, tmp_ctx, &r_scset_start);
 369         torture_assert_ntstatus_ok(tctx, status,
 370                                    "StartShadowCopySet failed");
 371
 372         ZERO_STRUCT(r_scset_abort);
 373         r_scset_abort.in.ShadowCopySetId = *r_scset_start.out.pShadowCopySetId;
 374         status = dcerpc_fss_AbortShadowCopySet_r(b, tmp_ctx, &r_scset_abort);
 375         torture_assert_ntstatus_ok(tctx, status,
 376                                    "AbortShadowCopySet failed");
 377
 378         ZERO_STRUCT(r_scset_add);
 379         r_scset_add.in.ClientShadowCopyId = GUID_random();
 380         r_scset_add.in.ShadowCopySetId = *r_scset_start.out.pShadowCopySetId;
 381         r_scset_add.in.ShareName = share_unc;
 382         status = dcerpc_fss_AddToShadowCopySet_r(b, tmp_ctx, &r_scset_add);
 383         torture_assert_ntstatus_ok(tctx, status, "AddToShadowCopySet failed "
 384                                    "following abort");
 385         /*
 386          * XXX Windows 8 server beta returns FSRVP_E_BAD_STATE here rather than
 387          * FSRVP_E_BAD_ID / E_INVALIDARG.
 388          */
 389         torture_assert(tctx, (r_scset_add.out.result != 0),
 390                        "incorrect AddToShadowCopySet response following abort");
 391
 392         talloc_free(tmp_ctx);
 393         return true;
 394 }
 395
 396 static bool test_fsrvp_bad_id(struct torture_context *tctx,
 397                               struct dcerpc_pipe *p)
 398 {
 399         struct fssagent_share_mapping_1 *sc_map;
 400         struct dcerpc_binding_handle *b = p->binding_handle;
 401         struct fss_DeleteShareMapping r_sharemap_del;
 402         NTSTATUS status;
 403         TALLOC_CTX *tmp_ctx = talloc_new(tctx);
 404         char *share_unc = talloc_asprintf(tmp_ctx, "\\\\%s\\%s\\",
 405                                           dcerpc_server_name(p), FSHARE);
 406
 407         torture_assert(tctx, test_fsrvp_sc_create(tctx, p, share_unc, &sc_map),
 408                        "sc create");
 409
 410         ZERO_STRUCT(r_sharemap_del);
 411         r_sharemap_del.in.ShadowCopySetId = sc_map->ShadowCopySetId;
 412         r_sharemap_del.in.ShadowCopySetId.time_low++;   /* bogus */
 413         r_sharemap_del.in.ShadowCopyId = sc_map->ShadowCopyId;
 414         r_sharemap_del.in.ShareName = sc_map->ShareNameUNC;
 415         status = dcerpc_fss_DeleteShareMapping_r(b, tmp_ctx, &r_sharemap_del);
 416         torture_assert_ntstatus_ok(tctx, status,
 417                                    "DeleteShareMapping failed");
 418         torture_assert_int_equal(tctx, r_sharemap_del.out.result,
 419                                  FSRVP_E_OBJECT_NOT_FOUND,
 420                                  "incorrect DeleteShareMapping response");
 421
 422         r_sharemap_del.in.ShadowCopySetId = sc_map->ShadowCopySetId;
 423         r_sharemap_del.in.ShadowCopyId.time_mid++;      /* bogus */
 424         status = dcerpc_fss_DeleteShareMapping_r(b, tmp_ctx, &r_sharemap_del);
 425         torture_assert_ntstatus_ok(tctx, status,
 426                                    "DeleteShareMapping failed");
 427         torture_assert_int_equal(tctx, r_sharemap_del.out.result,
 428                                  E_INVALIDARG,
 429                                  "incorrect DeleteShareMapping response");
 430
 431         torture_assert(tctx, test_fsrvp_sc_delete(tctx, p, sc_map), "sc del");
 432
 433         talloc_free(sc_map);
 434         talloc_free(tmp_ctx);
 435
 436         return true;
 437 }
 438
 439 static bool test_fsrvp_sc_share_io(struct torture_context *tctx,
 440                                    struct dcerpc_pipe *p)
 441 {
 442         struct fssagent_share_mapping_1 *sc_map;
 443         NTSTATUS status;
 444         TALLOC_CTX *tmp_ctx = talloc_new(tctx);
 445         char *share_unc = talloc_asprintf(tmp_ctx, "\\\\%s\\%s",
 446                                           dcerpc_server_name(p), FSHARE);
 447         extern struct cli_credentials *cmdline_credentials;
 448         struct smb2_tree *tree_base;
 449         struct smb2_tree *tree_snap;
 450         struct smbcli_options options;
 451         struct smb2_handle base_fh;
 452         struct smb2_read r;
 453         struct smb2_create io;
 454         lpcfg_smbcli_options(tctx->lp_ctx, &options);
 455
 456         status = smb2_connect(tmp_ctx,
 457                               dcerpc_server_name(p),
 458                               lpcfg_smb_ports(tctx->lp_ctx),
 459                               FSHARE,
 460                               lpcfg_resolve_context(tctx->lp_ctx),
 461                               cmdline_credentials,
 462                               &tree_base,
 463                               tctx->ev,
 464                               &options,
 465                               lpcfg_socket_options(tctx->lp_ctx),
 466                               lpcfg_gensec_settings(tctx, tctx->lp_ctx));
 467         torture_assert_ntstatus_ok(tctx, status,
 468                                    "Failed to connect to SMB2 share");
 469
 470         smb2_util_unlink(tree_base, FNAME);
 471         status = torture_smb2_testfile(tree_base, FNAME, &base_fh);
 472         torture_assert_ntstatus_ok(tctx, status, "base write open");
 473
 474         status = smb2_util_write(tree_base, base_fh, "pre-snap", 0,
 475                                  sizeof("pre-snap"));
 476         torture_assert_ntstatus_ok(tctx, status, "src write");
 477
 478
 479         torture_assert(tctx, test_fsrvp_sc_create(tctx, p, share_unc, &sc_map),
 480                        "sc create");
 481
 482         status = smb2_util_write(tree_base, base_fh, "post-snap", 0,
 483                                  sizeof("post-snap"));
 484         torture_assert_ntstatus_ok(tctx, status, "base write");
 485
 486         /* connect to snapshot share and verify pre-snapshot data */
 487         status = smb2_connect(tmp_ctx,
 488                               dcerpc_server_name(p),
 489                               lpcfg_smb_ports(tctx->lp_ctx),
 490                               sc_map->ShadowCopyShareName,
 491                               lpcfg_resolve_context(tctx->lp_ctx),
 492                               cmdline_credentials,
 493                               &tree_snap,
 494                               tctx->ev,
 495                               &options,
 496                               lpcfg_socket_options(tctx->lp_ctx),
 497                               lpcfg_gensec_settings(tctx, tctx->lp_ctx));
 498         torture_assert_ntstatus_ok(tctx, status,
 499                                    "Failed to connect to SMB2 shadow-copy share");
 500         /* Windows server 8 allows RW open to succeed here for a ro snapshot */
 501         ZERO_STRUCT(io);
 502         io.in.desired_access = SEC_RIGHTS_FILE_READ;
 503         io.in.file_attributes   = FILE_ATTRIBUTE_NORMAL;
 504         io.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
 505         io.in.share_access =
 506                 NTCREATEX_SHARE_ACCESS_DELETE|
 507                 NTCREATEX_SHARE_ACCESS_READ|
 508                 NTCREATEX_SHARE_ACCESS_WRITE;
 509         io.in.create_options = 0;
 510         io.in.fname = FNAME;
 511         status = smb2_create(tree_snap, tmp_ctx, &io);
 512         torture_assert_ntstatus_ok(tctx, status, "snap read open");
 513
 514         ZERO_STRUCT(r);
 515         r.in.file.handle = io.out.file.handle;
 516         r.in.length      = sizeof("pre-snap");
 517         status = smb2_read(tree_snap, tmp_ctx, &r);
 518         torture_assert_ntstatus_ok(tctx, status, "read");
 519         torture_assert_u64_equal(tctx, r.out.data.length, r.in.length,
 520                                  "read data len mismatch");
 521         torture_assert_str_equal(tctx, (char *)r.out.data.data, "pre-snap",
 522                                  "bad snapshot data");
 523
 524         torture_assert(tctx, test_fsrvp_sc_delete(tctx, p, sc_map), "sc del");
 525
 526         talloc_free(sc_map);
 527         talloc_free(tmp_ctx);
 528
 529         return true;
 530 }
 531
 532 static bool test_fsrvp_enum_snaps(struct torture_context *tctx,
 533                                   TALLOC_CTX *mem_ctx,
 534                                   struct smb2_tree *tree,
 535                                   struct smb2_handle fh,
 536                                   int *_count)
 537 {
 538         struct smb2_ioctl io;
 539         NTSTATUS status;
 540
 541         ZERO_STRUCT(io);
 542         io.level = RAW_IOCTL_SMB2;
 543         io.in.file.handle = fh;
 544         io.in.function = FSCTL_SRV_ENUM_SNAPS;
 545         io.in.max_response_size = 16;
 546         io.in.flags = SMB2_IOCTL_FLAG_IS_FSCTL;
 547
 548         status = smb2_ioctl(tree, mem_ctx, &io);
 549         torture_assert_ntstatus_ok(tctx, status, "enum ioctl");
 550
 551         *_count = IVAL(io.out.out.data, 0);
 552
 553         return true;
 554 }
 555
 556 static bool test_fsrvp_enum_created(struct torture_context *tctx,
 557                                     struct dcerpc_pipe *p)
 558 {
 559         struct fssagent_share_mapping_1 *sc_map;
 560         NTSTATUS status;
 561         TALLOC_CTX *tmp_ctx = talloc_new(tctx);
 562         char *share_unc = talloc_asprintf(tmp_ctx, "\\\\%s\\%s\\",
 563                                           dcerpc_server_name(p), FSHARE);
 564         extern struct cli_credentials *cmdline_credentials;
 565         struct smb2_tree *tree_base;
 566         struct smbcli_options options;
 567         struct smb2_handle base_fh;
 568         int count;
 569         lpcfg_smbcli_options(tctx->lp_ctx, &options);
 570
 571         status = smb2_connect(tmp_ctx,
 572                               dcerpc_server_name(p),
 573                               lpcfg_smb_ports(tctx->lp_ctx),
 574                               FSHARE,
 575                               lpcfg_resolve_context(tctx->lp_ctx),
 576                               cmdline_credentials,
 577                               &tree_base,
 578                               tctx->ev,
 579                               &options,
 580                               lpcfg_socket_options(tctx->lp_ctx),
 581                               lpcfg_gensec_settings(tctx, tctx->lp_ctx));
 582         torture_assert_ntstatus_ok(tctx, status,
 583                                    "Failed to connect to SMB2 share");
 584
 585         smb2_util_unlink(tree_base, FNAME);
 586         status = torture_smb2_testfile(tree_base, FNAME, &base_fh);
 587         torture_assert_ntstatus_ok(tctx, status, "base write open");
 588
 589         status = smb2_util_write(tree_base, base_fh, "pre-snap", 0,
 590                                  sizeof("pre-snap"));
 591         torture_assert_ntstatus_ok(tctx, status, "src write");
 592
 593         torture_assert(tctx,
 594                        test_fsrvp_enum_snaps(tctx, tmp_ctx, tree_base, base_fh,
 595                                              &count),
 596                        "count");
 597         torture_assert_int_equal(tctx, count, 0, "num snaps");
 598
 599         torture_assert(tctx, test_fsrvp_sc_create(tctx, p, share_unc, &sc_map),
 600                        "sc create");
 601         talloc_free(sc_map);
 602
 603         torture_assert(tctx,
 604                        test_fsrvp_enum_snaps(tctx, tmp_ctx, tree_base, base_fh,
 605                                              &count),
 606                        "count");
 607         /*
 608          * Snapshots created via FSRVP on Windows Server 2012 are not added to
 609          * the previous versions list, so it will fail here...
 610          */
 611         torture_assert_int_equal(tctx, count, 1, "num snaps");
 612
 613         smb_msleep(1100);       /* @GMT tokens have a 1 second resolution */
 614         torture_assert(tctx, test_fsrvp_sc_create(tctx, p, share_unc, &sc_map),
 615                        "sc create");
 616         talloc_free(sc_map);
 617
 618         torture_assert(tctx,
 619                        test_fsrvp_enum_snaps(tctx, tmp_ctx, tree_base, base_fh,
 620                                              &count),
 621                        "count");
 622         torture_assert_int_equal(tctx, count, 2, "num snaps");
 623
 624         talloc_free(tmp_ctx);
 625
 626         return true;
 627 }
 628
 629 static bool fsrvp_rpc_setup(struct torture_context *tctx, void **data)
 630 {
 631         NTSTATUS status;
 632         struct torture_rpc_tcase *tcase = talloc_get_type(
 633                                                 tctx->active_tcase, struct torture_rpc_tcase);
 634         struct torture_rpc_tcase_data *tcase_data;
 635         extern struct cli_credentials *cmdline_credentials;
 636
 637         *data = tcase_data = talloc_zero(tctx, struct torture_rpc_tcase_data);
 638         tcase_data->credentials = cmdline_credentials;
 639
 640         status = torture_rpc_connection(tctx,
 641                                 &(tcase_data->pipe),
 642                                 tcase->table);
 643
 644         torture_assert_ntstatus_ok(tctx, status, "Error connecting to server");
 645
 646         /* XXX required, otherwise ndr out ptrs are not allocated */
 647         tcase_data->pipe->conn->flags |= DCERPC_NDR_REF_ALLOC;
 648
 649         return true;
 650 }
 651
 652 /*
 653    testing of FSRVP (FSS agent)
 654 */
 655 struct torture_suite *torture_rpc_fsrvp(TALLOC_CTX *mem_ctx)
 656 {
 657         struct torture_suite *suite = torture_suite_create(mem_ctx, "fsrvp");
 658
 659         struct torture_rpc_tcase *tcase
 660                 = torture_suite_add_rpc_iface_tcase(suite, "fsrvp",
 661                                                 &ndr_table_FileServerVssAgent);
 662         /* override torture_rpc_setup() to set DCERPC_NDR_REF_ALLOC */
 663         tcase->tcase.setup = fsrvp_rpc_setup;
 664
 665         torture_rpc_tcase_add_test(tcase, "enum_created",
 666                                    test_fsrvp_enum_created);
 667         torture_rpc_tcase_add_test(tcase, "sc_share_io",
 668                                    test_fsrvp_sc_share_io);
 669         torture_rpc_tcase_add_test(tcase, "bad_id",
 670                                    test_fsrvp_bad_id);
 671         torture_rpc_tcase_add_test(tcase, "sc_set_abort",
 672                                    test_fsrvp_sc_set_abort);
 673         torture_rpc_tcase_add_test(tcase, "create_simple",
 674                                    test_fsrvp_sc_create_simple);
 675         torture_rpc_tcase_add_test(tcase, "set_ctx",
 676                                    test_fsrvp_set_ctx);
 677         torture_rpc_tcase_add_test(tcase, "get_version",
 678                                    test_fsrvp_get_version);
 679         torture_rpc_tcase_add_test(tcase, "is_path_supported",
 680                                    test_fsrvp_is_path_supported);
 681
 682         return suite;
 683 }