source4/torture/raw/session.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    test suite for session setup operations
   4    Copyright (C) Gregor Beck 2012
   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 "torture.h"
  22 #include "smb_cli.h"
  23 #include "torture/raw/proto.h"
  24 #include "smb_composite/smb_composite.h"
  25 #include "lib/cmdline/popt_common.h"
  26 #include "param/param.h"
  27 #include "torture/util.h"
  28 #include "auth/credentials/credentials.h"
  29
  30
  31 static bool test_session_reauth1(struct torture_context *tctx,
  32                                  struct smbcli_state *cli)
  33 {
  34         NTSTATUS status;
  35         struct smb_composite_sesssetup io;
  36         int fnum, num;
  37         const int dlen = 255;
  38         char *data;
  39         char fname[256];
  40         char buf[dlen+1];
  41         bool ok = true;
  42         uint16_t vuid1 = cli->session->vuid;
  43
  44         data = generate_random_str(tctx, dlen);
  45         torture_assert(tctx, (data != NULL), "memory allocation failed");
  46         snprintf(fname, sizeof(fname), "raw_session_reconnect_%.8s.dat", data);
  47
  48         fnum = smbcli_nt_create_full(cli->tree, fname, 0,
  49                                      SEC_RIGHTS_FILE_ALL,
  50                                      FILE_ATTRIBUTE_NORMAL,
  51                                      NTCREATEX_SHARE_ACCESS_NONE,
  52                                      NTCREATEX_DISP_OPEN_IF,
  53                                      NTCREATEX_OPTIONS_DELETE_ON_CLOSE,
  54                                      0);
  55         torture_assert_ntstatus_ok_goto(tctx, smbcli_nt_error(cli->tree), ok,
  56                                         done, "create file");
  57         torture_assert_goto(tctx, fnum > 0, ok, done, "create file");
  58
  59         num = smbcli_smbwrite(cli->tree, fnum, data, 0, dlen);
  60         torture_assert_int_equal_goto(tctx, num, dlen, ok, done, "write file");
  61
  62         ZERO_STRUCT(io);
  63         io.in.sesskey         = cli->transport->negotiate.sesskey;
  64         io.in.capabilities    = cli->transport->negotiate.capabilities;
  65         io.in.credentials     = cmdline_credentials;
  66         io.in.workgroup       = lpcfg_workgroup(tctx->lp_ctx);
  67         io.in.gensec_settings = lpcfg_gensec_settings(tctx, tctx->lp_ctx);
  68         status = smb_composite_sesssetup(cli->session, &io);
  69         torture_assert_ntstatus_ok_goto(tctx, status, ok, done, "setup2");
  70         torture_assert_int_equal_goto(tctx, io.out.vuid, vuid1, ok, done, "setup2");
  71
  72         num = smbcli_read(cli->tree, fnum, &buf, 0, dlen);
  73         torture_assert_int_equal_goto(tctx, num, dlen, ok, done, "read file");
  74         torture_assert_str_equal_goto(tctx, buf, data, ok, done, "read file");
  75
  76 done:
  77         talloc_free(data);
  78
  79         if (fnum > 0) {
  80                 status = smbcli_close(cli->tree, fnum);
  81                 torture_assert_ntstatus_ok(tctx, status, "close");
  82         }
  83         return ok;
  84 }
  85
  86 static bool test_session_reauth2_oplock_timeout(
  87         struct smbcli_transport *transport, uint16_t tid, uint16_t fnum,
  88         uint8_t level, void *private_data)
  89 {
  90         return true;
  91 }
  92
  93 static bool test_session_reauth2(struct torture_context *tctx,
  94                                  struct smbcli_state *cli)
  95 {
  96         char *random_string;
  97         char *fname;
  98         union smb_open io_open;
  99         struct smb_composite_sesssetup io_sesssetup;
 100         union smb_fileinfo io_qsecdesc;
 101         struct smbcli_request *req;
 102         struct cli_credentials *anon_creds;
 103         NTSTATUS status;
 104         uint16_t fnum;
 105         ssize_t nwritten;
 106         uint16_t vuid1 = cli->session->vuid;
 107
 108         random_string = generate_random_str(tctx, 8);
 109         torture_assert(tctx, (random_string != NULL),
 110                        "memory allocation failed");
 111         fname = talloc_asprintf(tctx, "raw_session_reauth2_%s.dat",
 112                                 random_string);
 113         talloc_free(random_string);
 114         torture_assert(tctx, (fname != NULL), "memory allocation failed");
 115
 116         smbcli_unlink(cli->tree, fname);
 117         smbcli_oplock_handler(cli->transport,
 118                               test_session_reauth2_oplock_timeout,
 119                               cli->tree);
 120
 121         /*
 122           base ntcreatex parms
 123         */
 124         ZERO_STRUCT(io_open);
 125         io_open.generic.level = RAW_OPEN_NTCREATEX;
 126         io_open.ntcreatex.in.root_fid.fnum = 0;
 127         io_open.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_READ |
 128                 SEC_RIGHTS_FILE_WRITE | SEC_STD_DELETE;
 129         io_open.ntcreatex.in.alloc_size = 0;
 130         io_open.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
 131         io_open.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
 132                                        NTCREATEX_SHARE_ACCESS_WRITE;
 133         io_open.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN_IF;
 134         io_open.ntcreatex.in.create_options = 0;
 135         io_open.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
 136         io_open.ntcreatex.in.security_flags = 0;
 137         io_open.ntcreatex.in.fname = fname;
 138
 139         torture_comment(tctx, "open with batch oplock\n");
 140         io_open.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED |
 141                 NTCREATEX_FLAGS_REQUEST_OPLOCK |
 142                 NTCREATEX_FLAGS_REQUEST_BATCH_OPLOCK;
 143
 144         status = smb_raw_open(cli->tree, tctx, &io_open);
 145         torture_assert_ntstatus_ok(tctx, status, "smb_raw_open failed");
 146
 147         fnum = io_open.ntcreatex.out.file.fnum;
 148         torture_assert(
 149                 tctx,
 150                 (io_open.ntcreatex.out.oplock_level == BATCH_OPLOCK_RETURN),
 151                 "did not get batch oplock");
 152
 153         io_open.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED;
 154         req = smb_raw_open_send(cli->tree, &io_open);
 155         torture_assert(tctx, (req != NULL), "memory allocation failed");
 156
 157         /*
 158          * Make sure the open went through
 159          */
 160         status = smbcli_chkpath(cli->tree, "\\");
 161         torture_assert_ntstatus_ok(tctx, status, "smb_chkpath failed");
 162
 163         status = smbcli_nt_delete_on_close(cli->tree, fnum, true);
 164         torture_assert_ntstatus_ok(tctx, status, "could not set delete on "
 165                                    "close");
 166
 167         anon_creds = cli_credentials_init_anon(tctx);
 168         torture_assert(tctx, (anon_creds != NULL), "memory allocation failed");
 169
 170         ZERO_STRUCT(io_sesssetup);
 171         io_sesssetup.in.sesskey      = cli->transport->negotiate.sesskey;
 172         io_sesssetup.in.capabilities = cli->transport->negotiate.capabilities;
 173         io_sesssetup.in.credentials  = anon_creds;
 174         io_sesssetup.in.workgroup    = lpcfg_workgroup(tctx->lp_ctx);
 175         io_sesssetup.in.gensec_settings = lpcfg_gensec_settings(
 176                 tctx, tctx->lp_ctx);
 177         status = smb_composite_sesssetup(cli->session, &io_sesssetup);
 178         torture_assert_ntstatus_ok(tctx, status, "setup2 failed");
 179         torture_assert_int_equal(tctx, io_sesssetup.out.vuid, vuid1, "setup2");
 180
 181         status = smbcli_close(cli->tree, fnum);
 182         torture_assert_ntstatus_ok(tctx, status, "close failed");
 183
 184         status = smb_raw_open_recv(req, tctx, &io_open);
 185         torture_assert_ntstatus_ok(tctx, status, "2nd open failed");
 186
 187         fnum = io_open.ntcreatex.out.file.fnum;
 188
 189         nwritten = smbcli_write(cli->tree, fnum, 0, fname, 0, strlen(fname));
 190         torture_assert(tctx, (nwritten == strlen(fname)),
 191                        "smbcli_write failed");
 192
 193         ZERO_STRUCT(io_qsecdesc);
 194         io_qsecdesc.query_secdesc.level = RAW_FILEINFO_SEC_DESC;
 195         io_qsecdesc.query_secdesc.in.file.fnum = fnum;
 196         io_qsecdesc.query_secdesc.in.secinfo_flags = SECINFO_OWNER;
 197         status = smb_raw_fileinfo(cli->tree, tctx, &io_qsecdesc);
 198         torture_assert_ntstatus_equal(
 199                 tctx, status, NT_STATUS_ACCESS_DENIED,
 200                 "anon qsecdesc did not return ACCESS_DENIED");
 201
 202         ZERO_STRUCT(io_sesssetup);
 203         io_sesssetup.in.sesskey      = cli->transport->negotiate.sesskey;
 204         io_sesssetup.in.capabilities = cli->transport->negotiate.capabilities;
 205         io_sesssetup.in.credentials  = cmdline_credentials;
 206         io_sesssetup.in.workgroup    = lpcfg_workgroup(tctx->lp_ctx);
 207         io_sesssetup.in.gensec_settings = lpcfg_gensec_settings(
 208                 tctx, tctx->lp_ctx);
 209         status = smb_composite_sesssetup(cli->session, &io_sesssetup);
 210         torture_assert_ntstatus_ok(tctx, status, "setup3 failed");
 211         torture_assert_int_equal(tctx, io_sesssetup.out.vuid, vuid1, "setup2");
 212
 213         status = smb_raw_fileinfo(cli->tree, tctx, &io_qsecdesc);
 214         torture_assert_ntstatus_ok(tctx, status, "2nd qsecdesc failed");
 215
 216         status = smbcli_nt_delete_on_close(cli->tree, fnum, true);
 217         torture_assert_ntstatus_ok(tctx, status, "could not set delete on "
 218                                    "close");
 219
 220         status = smbcli_close(cli->tree, fnum);
 221         torture_assert_ntstatus_ok(tctx, status, "close failed");
 222
 223         return true;
 224 }
 225
 226 struct torture_suite *torture_raw_session(TALLOC_CTX *mem_ctx)
 227 {
 228         struct torture_suite *suite = torture_suite_create(mem_ctx, "session");
 229         suite->description = talloc_strdup(suite, "RAW-SESSION tests");
 230
 231         torture_suite_add_1smb_test(suite, "reauth1", test_session_reauth1);
 232         torture_suite_add_1smb_test(suite, "reauth2", test_session_reauth2);
 233
 234         return suite;
 235 }