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