source4/torture/raw/notify.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    basic raw test suite for change notify
   4    Copyright (C) Andrew Tridgell 2003
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18 */
  19
  20 #include "includes.h"
  21 #include "libcli/raw/libcliraw.h"
  22 #include "libcli/raw/raw_proto.h"
  23 #include "libcli/libcli.h"
  24 #include "system/filesys.h"
  25 #include "torture/util.h"
  26 #include "torture/raw/proto.h"
  27
  28 #define BASEDIR "\\test_notify"
  29
  30 #define CHECK_WSTR(tctx, field, value, flags) \
  31 do { \
  32         torture_assert_str_equal(tctx, field.s, value, "values don't match"); \
  33         torture_assert(tctx, \
  34                        !wire_bad_flags(&field, STR_UNICODE, cli->transport), \
  35                        "wire_bad_flags"); \
  36 } while (0)
  37
  38 /*
  39    basic testing of change notify on directories
  40 */
  41 static bool test_notify_dir(struct torture_context *tctx,
  42                             struct smbcli_state *cli,
  43                             struct smbcli_state *cli2)
  44 {
  45         bool ret = true;
  46         NTSTATUS status;
  47         union smb_notify notify;
  48         union smb_open io;
  49         union smb_close cl;
  50         int i, count, fnum, fnum2;
  51         struct smbcli_request *req, *req2;
  52         extern int torture_numops;
  53
  54         torture_comment(tctx, "TESTING CHANGE NOTIFY ON DIRECTORIES\n");
  55
  56         torture_assert(tctx, torture_setup_dir(cli, BASEDIR),
  57                        "Failed to setup up test directory: " BASEDIR);
  58
  59         /*
  60           get a handle on the directory
  61         */
  62         io.generic.level = RAW_OPEN_NTCREATEX;
  63         io.ntcreatex.in.root_fid.fnum = 0;
  64         io.ntcreatex.in.flags = 0;
  65         io.ntcreatex.in.access_mask = SEC_FILE_ALL;
  66         io.ntcreatex.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
  67         io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
  68         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ | NTCREATEX_SHARE_ACCESS_WRITE;
  69         io.ntcreatex.in.alloc_size = 0;
  70         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN;
  71         io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
  72         io.ntcreatex.in.security_flags = 0;
  73         io.ntcreatex.in.fname = BASEDIR;
  74
  75         status = smb_raw_open(cli->tree, tctx, &io);
  76         torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
  77                                         "smb_raw_open");
  78         fnum = io.ntcreatex.out.file.fnum;
  79
  80         status = smb_raw_open(cli->tree, tctx, &io);
  81         torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
  82                                         "smb_raw_open");
  83         fnum2 = io.ntcreatex.out.file.fnum;
  84
  85         /* ask for a change notify,
  86            on file or directory name changes */
  87         notify.nttrans.level = RAW_NOTIFY_NTTRANS;
  88         notify.nttrans.in.buffer_size = 1000;
  89         notify.nttrans.in.completion_filter = FILE_NOTIFY_CHANGE_NAME;
  90         notify.nttrans.in.file.fnum = fnum;
  91         notify.nttrans.in.recursive = true;
  92
  93         torture_comment(tctx, "Testing notify cancel\n");
  94
  95         req = smb_raw_changenotify_send(cli->tree, &notify);
  96         smb_raw_ntcancel(req);
  97         status = smb_raw_changenotify_recv(req, tctx, &notify);
  98         torture_assert_ntstatus_equal_goto(tctx, status, NT_STATUS_CANCELLED,
  99                                            ret, done,
 100                                            "smb_raw_changenotify_recv");
 101
 102         torture_comment(tctx, "Testing notify mkdir\n");
 103
 104         req = smb_raw_changenotify_send(cli->tree, &notify);
 105         smbcli_mkdir(cli2->tree, BASEDIR "\\subdir-name");
 106
 107         status = smb_raw_changenotify_recv(req, tctx, &notify);
 108         torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
 109                                         "smb_raw_changenotify_recv");
 110
 111         torture_assert_int_equal_goto(tctx, notify.nttrans.out.num_changes,
 112                                       1, ret, done, "more than one change");
 113         torture_assert_int_equal_goto(tctx,
 114                                       notify.nttrans.out.changes[0].action,
 115                                       NOTIFY_ACTION_ADDED, ret, done,
 116                                       "wrong action (exp: ADDED)");
 117         CHECK_WSTR(tctx, notify.nttrans.out.changes[0].name, "subdir-name",
 118                    STR_UNICODE);
 119
 120         torture_comment(tctx, "Testing notify rmdir\n");
 121
 122         req = smb_raw_changenotify_send(cli->tree, &notify);
 123         smbcli_rmdir(cli2->tree, BASEDIR "\\subdir-name");
 124
 125         status = smb_raw_changenotify_recv(req, tctx, &notify);
 126         torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
 127                                         "smb_raw_changenotify_recv");
 128         torture_assert_int_equal_goto(tctx, notify.nttrans.out.num_changes,
 129                                       1, ret, done, "more than one change");
 130         torture_assert_int_equal_goto(tctx,
 131                                       notify.nttrans.out.changes[0].action,
 132                                       NOTIFY_ACTION_REMOVED, ret, done,
 133                                       "wrong action (exp: REMOVED)");
 134         CHECK_WSTR(tctx, notify.nttrans.out.changes[0].name, "subdir-name",
 135                    STR_UNICODE);
 136
 137         torture_comment(tctx, "Testing notify mkdir - rmdir - mkdir - rmdir\n");
 138
 139         smbcli_mkdir(cli2->tree, BASEDIR "\\subdir-name");
 140         smbcli_rmdir(cli2->tree, BASEDIR "\\subdir-name");
 141         smbcli_mkdir(cli2->tree, BASEDIR "\\subdir-name");
 142         smbcli_rmdir(cli2->tree, BASEDIR "\\subdir-name");
 143         smb_msleep(200);
 144         req = smb_raw_changenotify_send(cli->tree, &notify);
 145         status = smb_raw_changenotify_recv(req, tctx, &notify);
 146         torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
 147                                         "smb_raw_changenotify_recv");
 148         torture_assert_int_equal_goto(tctx, notify.nttrans.out.num_changes,
 149                                       4, ret, done, "wrong number of changes");
 150         torture_assert_int_equal_goto(tctx,
 151                                       notify.nttrans.out.changes[0].action,
 152                                       NOTIFY_ACTION_ADDED, ret, done,
 153                                       "wrong action (exp: ADDED)");
 154         CHECK_WSTR(tctx, notify.nttrans.out.changes[0].name, "subdir-name",
 155                    STR_UNICODE);
 156         torture_assert_int_equal_goto(tctx,
 157                                       notify.nttrans.out.changes[1].action,
 158                                       NOTIFY_ACTION_REMOVED, ret, done,
 159                                       "wrong action (exp: REMOVED)");
 160         CHECK_WSTR(tctx, notify.nttrans.out.changes[1].name, "subdir-name",
 161                    STR_UNICODE);
 162         torture_assert_int_equal_goto(tctx,
 163                                       notify.nttrans.out.changes[2].action,
 164                                       NOTIFY_ACTION_ADDED, ret, done,
 165                                       "wrong action (exp: ADDED)");
 166         CHECK_WSTR(tctx, notify.nttrans.out.changes[2].name, "subdir-name",
 167                    STR_UNICODE);
 168         torture_assert_int_equal_goto(tctx,
 169                                       notify.nttrans.out.changes[3].action,
 170                                       NOTIFY_ACTION_REMOVED, ret, done,
 171                                       "wrong action (exp: REMOVED)");
 172         CHECK_WSTR(tctx, notify.nttrans.out.changes[3].name, "subdir-name",
 173                    STR_UNICODE);
 174
 175         count = torture_numops;
 176         torture_comment(tctx, "Testing buffered notify on create of %d files\n", count);
 177         for (i=0;i<count;i++) {
 178                 char *fname = talloc_asprintf(cli, BASEDIR "\\test%d.txt", i);
 179                 int fnum3 = smbcli_open(cli->tree, fname, O_CREAT|O_RDWR, DENY_NONE);
 180                 torture_assert_int_not_equal_goto(tctx, fnum3, -1, ret, done,
 181                         talloc_asprintf(tctx, "Failed to create %s - %s",
 182                                         fname, smbcli_errstr(cli->tree)));
 183                 talloc_free(fname);
 184                 smbcli_close(cli->tree, fnum3);
 185         }
 186
 187         /* (1st notify) setup a new notify on a different directory handle.
 188            This new notify won't see the events above. */
 189         notify.nttrans.in.file.fnum = fnum2;
 190         req2 = smb_raw_changenotify_send(cli->tree, &notify);
 191
 192         /* (2nd notify) whereas this notify will see the above buffered events,
 193            and it directly returns the buffered events */
 194         notify.nttrans.in.file.fnum = fnum;
 195         req = smb_raw_changenotify_send(cli->tree, &notify);
 196
 197         status = smbcli_unlink(cli->tree, BASEDIR "\\nonexistent.txt");
 198         torture_assert_ntstatus_equal_goto(tctx, status,
 199                                            NT_STATUS_OBJECT_NAME_NOT_FOUND,
 200                                            ret, done,
 201                                            "smbcli_unlink");
 202
 203         /* (1st unlink) as the 2nd notify directly returns,
 204            this unlink is only seen by the 1st notify and
 205            the 3rd notify (later) */
 206         torture_comment(tctx, "Testing notify on unlink for the first file\n");
 207         status = smbcli_unlink(cli2->tree, BASEDIR "\\test0.txt");
 208         torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
 209                                         "smbcli_unlink");
 210
 211         /* receive the reply from the 2nd notify */
 212         status = smb_raw_changenotify_recv(req, tctx, &notify);
 213         torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
 214                                         "smb_raw_changenotify_recv");
 215
 216         torture_assert_int_equal_goto(tctx, notify.nttrans.out.num_changes,
 217                                       count, ret, done,
 218                                       "wrong number of changes");
 219         for (i=1;i<count;i++) {
 220                 torture_assert_int_equal_goto(tctx,
 221                                         notify.nttrans.out.changes[i].action,
 222                                         NOTIFY_ACTION_ADDED, ret, done,
 223                                         "wrong action (exp: ADDED)");
 224         }
 225         CHECK_WSTR(tctx, notify.nttrans.out.changes[0].name, "test0.txt",
 226                    STR_UNICODE);
 227
 228         torture_comment(tctx, "and now from the 1st notify\n");
 229         status = smb_raw_changenotify_recv(req2, tctx, &notify);
 230         torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
 231                                         "smb_raw_changenotify_recv");
 232         torture_assert_int_equal_goto(tctx, notify.nttrans.out.num_changes,
 233                                       1, ret, done, "wrong number of changes");
 234         torture_assert_int_equal_goto(tctx,
 235                                       notify.nttrans.out.changes[0].action,
 236                                       NOTIFY_ACTION_REMOVED, ret, done,
 237                                       "wrong action (exp: REMOVED)");
 238         CHECK_WSTR(tctx, notify.nttrans.out.changes[0].name, "test0.txt",
 239                    STR_UNICODE);
 240
 241         torture_comment(tctx, "(3rd notify) this notify will only see the 1st unlink\n");
 242         req = smb_raw_changenotify_send(cli->tree, &notify);
 243
 244         status = smbcli_unlink(cli->tree, BASEDIR "\\nonexistent.txt");
 245         torture_assert_ntstatus_equal_goto(tctx, status,
 246                                            NT_STATUS_OBJECT_NAME_NOT_FOUND,
 247                                            ret, done,
 248                                            "smbcli_unlink");
 249
 250         torture_comment(tctx, "Testing notify on wildcard unlink for %d files\n", count-1);
 251         /* (2nd unlink) do a wildcard unlink */
 252         status = smbcli_unlink(cli2->tree, BASEDIR "\\test*.txt");
 253         torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
 254                                         "smb_raw_changenotify_recv");
 255
 256         /* receive the 3rd notify */
 257         status = smb_raw_changenotify_recv(req, tctx, &notify);
 258         torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
 259                                         "smb_raw_changenotify_recv");
 260         torture_assert_int_equal_goto(tctx, notify.nttrans.out.num_changes,
 261                                       1, ret, done, "wrong number of changes");
 262         torture_assert_int_equal_goto(tctx,
 263                                       notify.nttrans.out.changes[0].action,
 264                                       NOTIFY_ACTION_REMOVED, ret, done,
 265                                       "wrong action (exp: REMOVED)");
 266         CHECK_WSTR(tctx, notify.nttrans.out.changes[0].name, "test0.txt",
 267                    STR_UNICODE);
 268
 269         /* and we now see the rest of the unlink calls on both directory handles */
 270         notify.nttrans.in.file.fnum = fnum;
 271         sleep(3);
 272         req = smb_raw_changenotify_send(cli->tree, &notify);
 273         status = smb_raw_changenotify_recv(req, tctx, &notify);
 274         torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
 275                                         "smb_raw_changenotify_recv");
 276         torture_assert_int_equal_goto(tctx, notify.nttrans.out.num_changes,
 277                                       count - 1, ret, done,
 278                                       "wrong number of changes");
 279         for (i=0;i<notify.nttrans.out.num_changes;i++) {
 280                 torture_assert_int_equal_goto(tctx,
 281                                         notify.nttrans.out.changes[i].action,
 282                                         NOTIFY_ACTION_REMOVED, ret, done,
 283                                         "wrong action (exp: REMOVED)");
 284         }
 285         notify.nttrans.in.file.fnum = fnum2;
 286         req = smb_raw_changenotify_send(cli->tree, &notify);
 287         status = smb_raw_changenotify_recv(req, tctx, &notify);
 288         torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
 289                                         "smb_raw_changenotify_recv");
 290         torture_assert_int_equal_goto(tctx, notify.nttrans.out.num_changes,
 291                                       count - 1, ret, done,
 292                                       "wrong number of changes");
 293         for (i=0;i<notify.nttrans.out.num_changes;i++) {
 294                 torture_assert_int_equal_goto(tctx,
 295                                         notify.nttrans.out.changes[i].action,
 296                                         NOTIFY_ACTION_REMOVED, ret, done,
 297                                         "wrong action (exp: REMOVED)");
 298         }
 299
 300         torture_comment(tctx, "Testing if a close() on the dir handle triggers the notify reply\n");
 301
 302         notify.nttrans.in.file.fnum = fnum;
 303         req = smb_raw_changenotify_send(cli->tree, &notify);
 304
 305         cl.close.level = RAW_CLOSE_CLOSE;
 306         cl.close.in.file.fnum = fnum;
 307         cl.close.in.write_time = 0;
 308         status = smb_raw_close(cli->tree, &cl);
 309         torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
 310                                         "smb_raw_close");
 311
 312         status = smb_raw_changenotify_recv(req, tctx, &notify);
 313         torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
 314                                         "smb_raw_changenotify_recv");
 315         torture_assert_int_equal_goto(tctx, notify.nttrans.out.num_changes,
 316                                       0, ret, done, "no changes expected");
 317
 318 done:
 319         smb_raw_exit(cli->session);
 320         smbcli_deltree(cli->tree, BASEDIR);
 321         return ret;
 322 }
 323
 324 /*
 325  * Check notify reply for a rename action. Not sure if this is a valid thing
 326  * to do, but depending on timing between inotify and messaging we get the
 327  * add/remove/modify in any order. This routines tries to find the action/name
 328  * pair in any of the three following notify_changes.
 329  */
 330
 331 static bool check_rename_reply(struct torture_context *tctx,
 332                                struct smbcli_state *cli,
 333                                int line,
 334                                struct notify_changes *actions,
 335                                uint32_t action, const char *name)
 336 {
 337         int i;
 338
 339         for (i=0; i<3; i++) {
 340                 if (actions[i].action == action) {
 341                         CHECK_WSTR(tctx, actions[i].name, name, STR_UNICODE);
 342                         return true;
 343                 }
 344         }
 345
 346         torture_result(tctx, TORTURE_FAIL,
 347                        __location__": (%d) expected action %d, not found\n",
 348                        line, action);
 349         return false;
 350 }
 351
 352 /*
 353    testing of recursive change notify
 354 */
 355 static bool test_notify_recursive(struct torture_context *tctx,
 356                                   struct smbcli_state *cli,
 357                                   struct smbcli_state *cli2)
 358 {
 359         bool ret = true;
 360         NTSTATUS status;
 361         union smb_notify notify;
 362         union smb_open io;
 363         int fnum;
 364         struct smbcli_request *req1, *req2;
 365
 366         torture_comment(tctx, "TESTING CHANGE NOTIFY WITH RECURSION\n");
 367
 368         torture_assert(tctx, torture_setup_dir(cli, BASEDIR),
 369                        "Failed to setup up test directory: " BASEDIR);
 370
 371         /*
 372           get a handle on the directory
 373         */
 374         io.generic.level = RAW_OPEN_NTCREATEX;
 375         io.ntcreatex.in.root_fid.fnum = 0;
 376         io.ntcreatex.in.flags = 0;
 377         io.ntcreatex.in.access_mask = SEC_FILE_ALL;
 378         io.ntcreatex.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
 379         io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
 380         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ | NTCREATEX_SHARE_ACCESS_WRITE;
 381         io.ntcreatex.in.alloc_size = 0;
 382         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN;
 383         io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
 384         io.ntcreatex.in.security_flags = 0;
 385         io.ntcreatex.in.fname = BASEDIR;
 386
 387         status = smb_raw_open(cli->tree, tctx, &io);
 388         torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
 389                                         "smb_raw_open");
 390         fnum = io.ntcreatex.out.file.fnum;
 391
 392         /* ask for a change notify, on file or directory name
 393            changes. Setup both with and without recursion */
 394         notify.nttrans.level = RAW_NOTIFY_NTTRANS;
 395         notify.nttrans.in.buffer_size = 1000;
 396         notify.nttrans.in.completion_filter = FILE_NOTIFY_CHANGE_NAME | FILE_NOTIFY_CHANGE_ATTRIBUTES | FILE_NOTIFY_CHANGE_CREATION;
 397         notify.nttrans.in.file.fnum = fnum;
 398
 399         notify.nttrans.in.recursive = true;
 400         req1 = smb_raw_changenotify_send(cli->tree, &notify);
 401
 402         notify.nttrans.in.recursive = false;
 403         req2 = smb_raw_changenotify_send(cli->tree, &notify);
 404
 405         /* cancel initial requests so the buffer is setup */
 406         smb_raw_ntcancel(req1);
 407         status = smb_raw_changenotify_recv(req1, tctx, &notify);
 408         torture_assert_ntstatus_equal_goto(tctx, status,
 409                                            NT_STATUS_CANCELLED,
 410                                            ret, done,
 411                                            "smb_raw_changenotify_recv");
 412
 413         smb_raw_ntcancel(req2);
 414         status = smb_raw_changenotify_recv(req2, tctx, &notify);
 415         torture_assert_ntstatus_equal_goto(tctx, status,
 416                                            NT_STATUS_CANCELLED,
 417                                            ret, done,
 418                                            "smb_raw_changenotify_recv");
 419
 420         /*
 421          * Make notifies a bit more interesting in a cluster by doing
 422          * the changes against different nodes with --unclist
 423          */
 424         smbcli_mkdir(cli->tree, BASEDIR "\\subdir-name");
 425         smbcli_mkdir(cli2->tree, BASEDIR "\\subdir-name\\subname1");
 426         smbcli_close(cli->tree,
 427                      smbcli_open(cli->tree, BASEDIR "\\subdir-name\\subname2", O_CREAT, 0));
 428         smbcli_rename(cli2->tree, BASEDIR "\\subdir-name\\subname1",
 429                       BASEDIR "\\subdir-name\\subname1-r");
 430         smbcli_rename(cli->tree, BASEDIR "\\subdir-name\\subname2", BASEDIR "\\subname2-r");
 431         smbcli_rename(cli2->tree, BASEDIR "\\subname2-r",
 432                       BASEDIR "\\subname3-r");
 433
 434         notify.nttrans.in.completion_filter = 0;
 435         notify.nttrans.in.recursive = true;
 436         smb_msleep(200);
 437         req1 = smb_raw_changenotify_send(cli->tree, &notify);
 438
 439         smbcli_rmdir(cli->tree, BASEDIR "\\subdir-name\\subname1-r");
 440         smbcli_rmdir(cli2->tree, BASEDIR "\\subdir-name");
 441         smbcli_unlink(cli->tree, BASEDIR "\\subname3-r");
 442
 443         smb_msleep(200);
 444         notify.nttrans.in.recursive = false;
 445         req2 = smb_raw_changenotify_send(cli->tree, &notify);
 446
 447         status = smb_raw_changenotify_recv(req1, tctx, &notify);
 448         torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
 449                                         "smb_raw_changenotify_recv");
 450
 451         torture_assert_int_equal_goto(tctx, notify.nttrans.out.num_changes,
 452                                       11, ret, done, "wrong number of changes");
 453         torture_assert_int_equal_goto(tctx,
 454                                       notify.nttrans.out.changes[0].action,
 455                                       NOTIFY_ACTION_ADDED, ret, done,
 456                                       "wrong action (exp: ADDED)");
 457         CHECK_WSTR(tctx, notify.nttrans.out.changes[0].name, "subdir-name",
 458                    STR_UNICODE);
 459         torture_assert_int_equal_goto(tctx,
 460                                       notify.nttrans.out.changes[1].action,
 461                                       NOTIFY_ACTION_ADDED, ret, done,
 462                                       "wrong action (exp: ADDED)");
 463         CHECK_WSTR(tctx, notify.nttrans.out.changes[1].name,
 464                    "subdir-name\\subname1", STR_UNICODE);
 465         torture_assert_int_equal_goto(tctx,
 466                                       notify.nttrans.out.changes[2].action,
 467                                       NOTIFY_ACTION_ADDED, ret, done,
 468                                       "wrong action (exp: ADDED)");
 469         CHECK_WSTR(tctx, notify.nttrans.out.changes[2].name,
 470                    "subdir-name\\subname2", STR_UNICODE);
 471         torture_assert_int_equal_goto(tctx,
 472                                       notify.nttrans.out.changes[3].action,
 473                                       NOTIFY_ACTION_OLD_NAME, ret, done,
 474                                       "wrong action (exp: OLD_NAME)");
 475         CHECK_WSTR(tctx, notify.nttrans.out.changes[3].name,
 476                    "subdir-name\\subname1", STR_UNICODE);
 477         torture_assert_int_equal_goto(tctx,
 478                                       notify.nttrans.out.changes[4].action,
 479                                       NOTIFY_ACTION_NEW_NAME, ret, done,
 480                                       "wrong action (exp: NEW_NAME)");
 481         CHECK_WSTR(tctx, notify.nttrans.out.changes[4].name,
 482                    "subdir-name\\subname1-r", STR_UNICODE);
 483
 484         ret &= check_rename_reply(tctx,
 485                 cli, __LINE__, &notify.nttrans.out.changes[5],
 486                 NOTIFY_ACTION_ADDED, "subname2-r");
 487         ret &= check_rename_reply(tctx,
 488                 cli, __LINE__, &notify.nttrans.out.changes[5],
 489                 NOTIFY_ACTION_REMOVED, "subdir-name\\subname2");
 490         ret &= check_rename_reply(tctx,
 491                 cli, __LINE__, &notify.nttrans.out.changes[5],
 492                 NOTIFY_ACTION_MODIFIED, "subname2-r");
 493
 494         ret &= check_rename_reply(tctx,
 495                 cli, __LINE__, &notify.nttrans.out.changes[8],
 496                 NOTIFY_ACTION_OLD_NAME, "subname2-r");
 497         ret &= check_rename_reply(tctx,
 498                 cli, __LINE__, &notify.nttrans.out.changes[8],
 499                 NOTIFY_ACTION_NEW_NAME, "subname3-r");
 500         ret &= check_rename_reply(tctx,
 501                 cli, __LINE__, &notify.nttrans.out.changes[8],
 502                 NOTIFY_ACTION_MODIFIED, "subname3-r");
 503
 504         if (!ret) {
 505                 goto done;
 506         }
 507
 508         status = smb_raw_changenotify_recv(req2, tctx, &notify);
 509         torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
 510                                         "smb_raw_changenotify_recv");
 511
 512         torture_assert_int_equal_goto(tctx, notify.nttrans.out.num_changes,
 513                                       3, ret, done, "wrong number of changes");
 514         torture_assert_int_equal_goto(tctx,
 515                                       notify.nttrans.out.changes[0].action,
 516                                       NOTIFY_ACTION_REMOVED, ret, done,
 517                                       "wrong action (exp: REMOVED)");
 518         CHECK_WSTR(tctx, notify.nttrans.out.changes[0].name,
 519                    "subdir-name\\subname1-r", STR_UNICODE);
 520         torture_assert_int_equal_goto(tctx,
 521                                       notify.nttrans.out.changes[1].action,
 522                                       NOTIFY_ACTION_REMOVED, ret, done,
 523                                       "wrong action (exp: REMOVED)");
 524         CHECK_WSTR(tctx, notify.nttrans.out.changes[1].name, "subdir-name",
 525                    STR_UNICODE);
 526         torture_assert_int_equal_goto(tctx,
 527                                       notify.nttrans.out.changes[2].action,
 528                                       NOTIFY_ACTION_REMOVED, ret, done,
 529                                       "wrong action (exp: REMOVED)");
 530         CHECK_WSTR(tctx, notify.nttrans.out.changes[2].name, "subname3-r",
 531                    STR_UNICODE);
 532
 533 done:
 534         smb_raw_exit(cli->session);
 535         smbcli_deltree(cli->tree, BASEDIR);
 536         return ret;
 537 }
 538
 539 /*
 540    testing of change notify mask change
 541 */
 542 static bool test_notify_mask_change(struct torture_context *tctx,
 543                                     struct smbcli_state *cli)
 544 {
 545         bool ret = true;
 546         NTSTATUS status;
 547         union smb_notify notify;
 548         union smb_open io;
 549         int fnum;
 550         struct smbcli_request *req1, *req2;
 551
 552         torture_comment(tctx, "TESTING CHANGE NOTIFY WITH MASK CHANGE\n");
 553
 554         torture_assert(tctx, torture_setup_dir(cli, BASEDIR),
 555                        "Failed to setup up test directory: " BASEDIR);
 556
 557         /*
 558           get a handle on the directory
 559         */
 560         io.generic.level = RAW_OPEN_NTCREATEX;
 561         io.ntcreatex.in.root_fid.fnum = 0;
 562         io.ntcreatex.in.flags = 0;
 563         io.ntcreatex.in.access_mask = SEC_FILE_ALL;
 564         io.ntcreatex.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
 565         io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
 566         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ | NTCREATEX_SHARE_ACCESS_WRITE;
 567         io.ntcreatex.in.alloc_size = 0;
 568         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN;
 569         io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
 570         io.ntcreatex.in.security_flags = 0;
 571         io.ntcreatex.in.fname = BASEDIR;
 572
 573         status = smb_raw_open(cli->tree, tctx, &io);
 574         torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
 575                                         "smb_raw_open");
 576         fnum = io.ntcreatex.out.file.fnum;
 577
 578         /* ask for a change notify, on file or directory name
 579            changes. Setup both with and without recursion */
 580         notify.nttrans.level = RAW_NOTIFY_NTTRANS;
 581         notify.nttrans.in.buffer_size = 1000;
 582         notify.nttrans.in.completion_filter = FILE_NOTIFY_CHANGE_ATTRIBUTES;
 583         notify.nttrans.in.file.fnum = fnum;
 584
 585         notify.nttrans.in.recursive = true;
 586         req1 = smb_raw_changenotify_send(cli->tree, &notify);
 587
 588         notify.nttrans.in.recursive = false;
 589         req2 = smb_raw_changenotify_send(cli->tree, &notify);
 590
 591         /* cancel initial requests so the buffer is setup */
 592         smb_raw_ntcancel(req1);
 593         status = smb_raw_changenotify_recv(req1, tctx, &notify);
 594         torture_assert_ntstatus_equal_goto(tctx, status,
 595                                            NT_STATUS_CANCELLED,
 596                                            ret, done,
 597                                            "smb_raw_changenotify_recv");
 598
 599         smb_raw_ntcancel(req2);
 600         status = smb_raw_changenotify_recv(req2, tctx, &notify);
 601         torture_assert_ntstatus_equal_goto(tctx, status,
 602                                            NT_STATUS_CANCELLED,
 603                                            ret, done,
 604                                            "smb_raw_changenotify_recv");
 605
 606         notify.nttrans.in.recursive = true;
 607         req1 = smb_raw_changenotify_send(cli->tree, &notify);
 608
 609         /* Set to hidden then back again. */
 610         smbcli_close(cli->tree, smbcli_open(cli->tree, BASEDIR "\\tname1", O_CREAT, 0));
 611         smbcli_setatr(cli->tree, BASEDIR "\\tname1", FILE_ATTRIBUTE_HIDDEN, 0);
 612         smbcli_unlink(cli->tree, BASEDIR "\\tname1");
 613
 614         status = smb_raw_changenotify_recv(req1, tctx, &notify);
 615         torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
 616                                         "smb_raw_changenotify_recv");
 617
 618         torture_assert_int_equal_goto(tctx, notify.nttrans.out.num_changes,
 619                                       1, ret, done, "wrong number of changes");
 620         torture_assert_int_equal_goto(tctx,
 621                                       notify.nttrans.out.changes[0].action,
 622                                       NOTIFY_ACTION_MODIFIED, ret, done,
 623                                       "wrong action (exp: MODIFIED)");
 624         CHECK_WSTR(tctx, notify.nttrans.out.changes[0].name, "tname1",
 625                    STR_UNICODE);
 626
 627         /* Now try and change the mask to include other events.
 628          * This should not work - once the mask is set on a directory
 629          * fnum it seems to be fixed until the fnum is closed. */
 630
 631         notify.nttrans.in.completion_filter = FILE_NOTIFY_CHANGE_NAME | FILE_NOTIFY_CHANGE_ATTRIBUTES | FILE_NOTIFY_CHANGE_CREATION;
 632         notify.nttrans.in.recursive = true;
 633         req1 = smb_raw_changenotify_send(cli->tree, &notify);
 634
 635         notify.nttrans.in.recursive = false;
 636         req2 = smb_raw_changenotify_send(cli->tree, &notify);
 637
 638         smbcli_mkdir(cli->tree, BASEDIR "\\subdir-name");
 639         smbcli_mkdir(cli->tree, BASEDIR "\\subdir-name\\subname1");
 640         smbcli_close(cli->tree,
 641                      smbcli_open(cli->tree, BASEDIR "\\subdir-name\\subname2", O_CREAT, 0));
 642         smbcli_rename(cli->tree, BASEDIR "\\subdir-name\\subname1", BASEDIR "\\subdir-name\\subname1-r");
 643         smbcli_rename(cli->tree, BASEDIR "\\subdir-name\\subname2", BASEDIR "\\subname2-r");
 644         smbcli_rename(cli->tree, BASEDIR "\\subname2-r", BASEDIR "\\subname3-r");
 645
 646         smbcli_rmdir(cli->tree, BASEDIR "\\subdir-name\\subname1-r");
 647         smbcli_rmdir(cli->tree, BASEDIR "\\subdir-name");
 648         smbcli_unlink(cli->tree, BASEDIR "\\subname3-r");
 649
 650         status = smb_raw_changenotify_recv(req1, tctx, &notify);
 651         torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
 652                                         "smb_raw_changenotify_recv");
 653
 654         torture_assert_int_equal_goto(tctx, notify.nttrans.out.num_changes,
 655                                       1, ret, done, "wrong number of changes");
 656         torture_assert_int_equal_goto(tctx,
 657                                       notify.nttrans.out.changes[0].action,
 658                                       NOTIFY_ACTION_MODIFIED, ret, done,
 659                                       "wrong action (exp: MODIFIED)");
 660         CHECK_WSTR(tctx, notify.nttrans.out.changes[0].name, "subname2-r",
 661                    STR_UNICODE);
 662
 663         status = smb_raw_changenotify_recv(req2, tctx, &notify);
 664         torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
 665                                         "smb_raw_changenotify_recv");
 666
 667         torture_assert_int_equal_goto(tctx, notify.nttrans.out.num_changes,
 668                                       1, ret, done, "wrong number of changes");
 669         torture_assert_int_equal_goto(tctx,
 670                                       notify.nttrans.out.changes[0].action,
 671                                       NOTIFY_ACTION_MODIFIED, ret, done,
 672                                       "wrong action (exp: MODIFIED)");
 673         CHECK_WSTR(tctx, notify.nttrans.out.changes[0].name, "subname3-r",
 674                    STR_UNICODE);
 675
 676 done:
 677         smb_raw_exit(cli->session);
 678         smbcli_deltree(cli->tree, BASEDIR);
 679         return ret;
 680 }
 681
 682
 683 /*
 684    testing of mask bits for change notify
 685 */
 686 static bool test_notify_mask(struct torture_context *tctx,
 687                              struct smbcli_state *cli,
 688                              struct smbcli_state *cli2)
 689 {
 690         bool ret = true;
 691         NTSTATUS status;
 692         union smb_notify notify;
 693         union smb_open io;
 694         union smb_chkpath chkpath;
 695         int fnum, fnum2;
 696         uint32_t mask;
 697         int i;
 698         char c = 1;
 699         struct timeval tv;
 700         NTTIME t;
 701
 702         torture_comment(tctx, "TESTING CHANGE NOTIFY COMPLETION FILTERS\n");
 703
 704         torture_assert(tctx, torture_setup_dir(cli, BASEDIR),
 705                        "Failed to setup up test directory: " BASEDIR);
 706
 707         tv = timeval_current_ofs(1000, 0);
 708         t = timeval_to_nttime(&tv);
 709
 710         /*
 711           get a handle on the directory
 712         */
 713         io.generic.level = RAW_OPEN_NTCREATEX;
 714         io.ntcreatex.in.root_fid.fnum = 0;
 715         io.ntcreatex.in.flags = 0;
 716         io.ntcreatex.in.access_mask = SEC_FILE_ALL;
 717         io.ntcreatex.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
 718         io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
 719         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ | NTCREATEX_SHARE_ACCESS_WRITE;
 720         io.ntcreatex.in.alloc_size = 0;
 721         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN;
 722         io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
 723         io.ntcreatex.in.security_flags = 0;
 724         io.ntcreatex.in.fname = BASEDIR;
 725
 726         notify.nttrans.level = RAW_NOTIFY_NTTRANS;
 727         notify.nttrans.in.buffer_size = 1000;
 728         notify.nttrans.in.recursive = true;
 729
 730         chkpath.chkpath.in.path = "\\";
 731
 732 #define NOTIFY_MASK_TEST(test_name, setup, op, cleanup, Action, expected, nchanges) \
 733         do { \
 734         smbcli_getatr(cli->tree, test_name, NULL, NULL, NULL); \
 735         for (mask=i=0;i<32;i++) { \
 736                 struct smbcli_request *req; \
 737                 status = smb_raw_open(cli->tree, tctx, &io); \
 738                 torture_assert_ntstatus_ok_goto(tctx, status, ret, done, \
 739                                                 "smb_raw_open"); \
 740                 fnum = io.ntcreatex.out.file.fnum; \
 741                 setup \
 742                 notify.nttrans.in.file.fnum = fnum;     \
 743                 notify.nttrans.in.completion_filter = (1<<i); \
 744                 req = smb_raw_changenotify_send(cli->tree, &notify); \
 745                 smb_raw_chkpath(cli->tree, &chkpath); \
 746                 op \
 747                 smb_msleep(200); smb_raw_ntcancel(req); \
 748                 status = smb_raw_changenotify_recv(req, tctx, &notify); \
 749                 cleanup \
 750                 smbcli_close(cli->tree, fnum); \
 751                 if (NT_STATUS_EQUAL(status, NT_STATUS_CANCELLED)) continue; \
 752                 torture_assert_ntstatus_ok_goto(tctx, status, ret, done, \
 753                                                 "smbcli_close"); \
 754                 /* special case to cope with file rename behaviour */ \
 755                 if (nchanges == 2 && notify.nttrans.out.num_changes == 1 && \
 756                     notify.nttrans.out.changes[0].action == NOTIFY_ACTION_MODIFIED && \
 757                     ((expected) & FILE_NOTIFY_CHANGE_ATTRIBUTES) && \
 758                     Action == NOTIFY_ACTION_OLD_NAME) { \
 759                         torture_comment(tctx, "(rename file special handling OK)\n"); \
 760                 } else { \
 761                         torture_assert_int_equal_goto(tctx, \
 762                                 notify.nttrans.out.num_changes,\
 763                                 nchanges, ret, done, \
 764                                 talloc_asprintf(tctx, \
 765                                         "nchanges=%d expected=%d action=%d " \
 766                                         "filter=0x%08x\n", \
 767                                         notify.nttrans.out.num_changes, \
 768                                         nchanges, \
 769                                         notify.nttrans.out.changes[0].action, \
 770                                         notify.nttrans.in.completion_filter)); \
 771                         torture_assert_int_equal_goto(tctx, \
 772                                 notify.nttrans.out.changes[0].action, \
 773                                 Action, ret, done, \
 774                                 talloc_asprintf(tctx, \
 775                                         "nchanges=%d action=%d " \
 776                                         "expectedAction=%d filter=0x%08x\n", \
 777                                         notify.nttrans.out.num_changes, \
 778                                         notify.nttrans.out.changes[0].action, \
 779                                         Action, \
 780                                         notify.nttrans.in.completion_filter)); \
 781                         torture_assert_str_equal_goto(tctx, \
 782                                 notify.nttrans.out.changes[0].name.s, \
 783                                 "tname1", ret, done, \
 784                                 talloc_asprintf(tctx, \
 785                                         "nchanges=%d action=%d filter=0x%08x " \
 786                                         "name=%s expected_name=tname1\n", \
 787                                         notify.nttrans.out.num_changes, \
 788                                         notify.nttrans.out.changes[0].action, \
 789                                         notify.nttrans.in.completion_filter, \
 790                                         notify.nttrans.out.changes[0].name.s));\
 791                 } \
 792                 mask |= (1<<i); \
 793         } \
 794         if ((expected) != mask) { \
 795                 torture_assert_int_not_equal_goto(tctx, ((expected) & ~mask), \
 796                                 0, ret, done, "Too few bits"); \
 797                 torture_comment(tctx, "WARNING: trigger on too many bits. mask=0x%08x expected=0x%08x\n", \
 798                        mask, expected); \
 799         } \
 800         } while (0);
 801
 802         torture_comment(tctx, "Testing mkdir\n");
 803         NOTIFY_MASK_TEST("Testing mkdir",;,
 804                          smbcli_mkdir(cli->tree, BASEDIR "\\tname1");,
 805                          smbcli_rmdir(cli2->tree, BASEDIR "\\tname1");,
 806                          NOTIFY_ACTION_ADDED,
 807                          FILE_NOTIFY_CHANGE_DIR_NAME, 1);
 808
 809         torture_comment(tctx, "Testing create file\n");
 810         NOTIFY_MASK_TEST("Testing create file",;,
 811                          smbcli_close(cli->tree, smbcli_open(cli->tree, BASEDIR "\\tname1", O_CREAT, 0));,
 812                          smbcli_unlink(cli2->tree, BASEDIR "\\tname1");,
 813                          NOTIFY_ACTION_ADDED,
 814                          FILE_NOTIFY_CHANGE_FILE_NAME, 1);
 815
 816         torture_comment(tctx, "Testing unlink\n");
 817         NOTIFY_MASK_TEST("Testing unlink",
 818                          smbcli_close(cli->tree, smbcli_open(cli->tree, BASEDIR "\\tname1", O_CREAT, 0));,
 819                          smbcli_unlink(cli2->tree, BASEDIR "\\tname1");,
 820                          ;,
 821                          NOTIFY_ACTION_REMOVED,
 822                          FILE_NOTIFY_CHANGE_FILE_NAME, 1);
 823
 824         torture_comment(tctx, "Testing rmdir\n");
 825         NOTIFY_MASK_TEST("Testing rmdir",
 826                          smbcli_mkdir(cli->tree, BASEDIR "\\tname1");,
 827                          smbcli_rmdir(cli2->tree, BASEDIR "\\tname1");,
 828                          ;,
 829                          NOTIFY_ACTION_REMOVED,
 830                          FILE_NOTIFY_CHANGE_DIR_NAME, 1);
 831
 832         torture_comment(tctx, "Testing rename file\n");
 833         NOTIFY_MASK_TEST("Testing rename file",
 834                          smbcli_close(cli->tree, smbcli_open(cli->tree, BASEDIR "\\tname1", O_CREAT, 0));,
 835                          smbcli_rename(cli2->tree, BASEDIR "\\tname1", BASEDIR "\\tname2");,
 836                          smbcli_unlink(cli->tree, BASEDIR "\\tname2");,
 837                          NOTIFY_ACTION_OLD_NAME,
 838                          FILE_NOTIFY_CHANGE_FILE_NAME|FILE_NOTIFY_CHANGE_ATTRIBUTES|FILE_NOTIFY_CHANGE_CREATION, 2);
 839
 840         torture_comment(tctx, "Testing rename dir\n");
 841         NOTIFY_MASK_TEST("Testing rename dir",
 842                 smbcli_mkdir(cli->tree, BASEDIR "\\tname1");,
 843                 smbcli_rename(cli2->tree, BASEDIR "\\tname1", BASEDIR "\\tname2");,
 844                 smbcli_rmdir(cli->tree, BASEDIR "\\tname2");,
 845                 NOTIFY_ACTION_OLD_NAME,
 846                 FILE_NOTIFY_CHANGE_DIR_NAME, 2);
 847
 848         torture_comment(tctx, "Testing set path attribute\n");
 849         NOTIFY_MASK_TEST("Testing set path attribute",
 850                 smbcli_close(cli->tree, smbcli_open(cli->tree, BASEDIR "\\tname1", O_CREAT, 0));,
 851                 smbcli_setatr(cli2->tree, BASEDIR "\\tname1", FILE_ATTRIBUTE_HIDDEN, 0);,
 852                 smbcli_unlink(cli->tree, BASEDIR "\\tname1");,
 853                 NOTIFY_ACTION_MODIFIED,
 854                 FILE_NOTIFY_CHANGE_ATTRIBUTES, 1);
 855
 856         torture_comment(tctx, "Testing set path write time\n");
 857         NOTIFY_MASK_TEST("Testing set path write time",
 858                 smbcli_close(cli->tree, smbcli_open(cli->tree, BASEDIR "\\tname1", O_CREAT, 0));,
 859                 smbcli_setatr(cli2->tree, BASEDIR "\\tname1", FILE_ATTRIBUTE_NORMAL, 1000);,
 860                 smbcli_unlink(cli->tree, BASEDIR "\\tname1");,
 861                 NOTIFY_ACTION_MODIFIED,
 862                 FILE_NOTIFY_CHANGE_LAST_WRITE, 1);
 863
 864         torture_comment(tctx, "Testing set file attribute\n");
 865         NOTIFY_MASK_TEST("Testing set file attribute",
 866                 fnum2 = create_complex_file(cli2, tctx, BASEDIR "\\tname1");,
 867                 smbcli_fsetatr(cli2->tree, fnum2, FILE_ATTRIBUTE_HIDDEN, 0, 0, 0, 0);,
 868                 (smbcli_close(cli2->tree, fnum2), smbcli_unlink(cli2->tree, BASEDIR "\\tname1"));,
 869                 NOTIFY_ACTION_MODIFIED,
 870                 FILE_NOTIFY_CHANGE_ATTRIBUTES, 1);
 871
 872         if (torture_setting_bool(tctx, "samba3", false)) {
 873                 torture_comment(tctx, "Samba3 does not yet support create times "
 874                        "everywhere\n");
 875         }
 876         else {
 877                 torture_comment(tctx, "Testing set file create time\n");
 878                 NOTIFY_MASK_TEST("Testing set file create time",
 879                         fnum2 = create_complex_file(cli, tctx,
 880                                                     BASEDIR "\\tname1");,
 881                         smbcli_fsetatr(cli->tree, fnum2, 0, t, 0, 0, 0);,
 882                         (smbcli_close(cli->tree, fnum2),
 883                          smbcli_unlink(cli->tree, BASEDIR "\\tname1"));,
 884                         NOTIFY_ACTION_MODIFIED,
 885                         FILE_NOTIFY_CHANGE_CREATION, 1);
 886         }
 887
 888         torture_comment(tctx, "Testing set file access time\n");
 889         NOTIFY_MASK_TEST("Testing set file access time",
 890                 fnum2 = create_complex_file(cli, tctx, BASEDIR "\\tname1");,
 891                 smbcli_fsetatr(cli->tree, fnum2, 0, 0, t, 0, 0);,
 892                 (smbcli_close(cli->tree, fnum2), smbcli_unlink(cli->tree, BASEDIR "\\tname1"));,
 893                 NOTIFY_ACTION_MODIFIED,
 894                 FILE_NOTIFY_CHANGE_LAST_ACCESS, 1);
 895
 896         torture_comment(tctx, "Testing set file write time\n");
 897         NOTIFY_MASK_TEST("Testing set file write time",
 898                 fnum2 = create_complex_file(cli, tctx, BASEDIR "\\tname1");,
 899                 smbcli_fsetatr(cli->tree, fnum2, 0, 0, 0, t, 0);,
 900                 (smbcli_close(cli->tree, fnum2), smbcli_unlink(cli->tree, BASEDIR "\\tname1"));,
 901                 NOTIFY_ACTION_MODIFIED,
 902                 FILE_NOTIFY_CHANGE_LAST_WRITE, 1);
 903
 904         torture_comment(tctx, "Testing set file change time\n");
 905         NOTIFY_MASK_TEST("Testing set file change time",
 906                 fnum2 = create_complex_file(cli, tctx, BASEDIR "\\tname1");,
 907                 smbcli_fsetatr(cli->tree, fnum2, 0, 0, 0, 0, t);,
 908                 (smbcli_close(cli->tree, fnum2), smbcli_unlink(cli->tree, BASEDIR "\\tname1"));,
 909                 NOTIFY_ACTION_MODIFIED,
 910                 0, 1);
 911
 912
 913         torture_comment(tctx, "Testing write\n");
 914         NOTIFY_MASK_TEST("Testing write",
 915                 fnum2 = create_complex_file(cli2, tctx, BASEDIR "\\tname1");,
 916                 smbcli_write(cli2->tree, fnum2, 1, &c, 10000, 1);,
 917                 (smbcli_close(cli2->tree, fnum2), smbcli_unlink(cli->tree, BASEDIR "\\tname1"));,
 918                 NOTIFY_ACTION_MODIFIED,
 919                 0, 1);
 920
 921         torture_comment(tctx, "Testing truncate\n");
 922         NOTIFY_MASK_TEST("Testing truncate",
 923                 fnum2 = create_complex_file(cli2, tctx, BASEDIR "\\tname1");,
 924                 smbcli_ftruncate(cli2->tree, fnum2, 10000);,
 925                 (smbcli_close(cli2->tree, fnum2), smbcli_unlink(cli2->tree, BASEDIR "\\tname1"));,
 926                 NOTIFY_ACTION_MODIFIED,
 927                 FILE_NOTIFY_CHANGE_SIZE | FILE_NOTIFY_CHANGE_ATTRIBUTES, 1);
 928
 929 done:
 930         smb_raw_exit(cli->session);
 931         smbcli_deltree(cli->tree, BASEDIR);
 932         return ret;
 933 }
 934
 935 /*
 936   basic testing of change notify on files
 937 */
 938 static bool test_notify_file(struct torture_context *tctx,
 939                              struct smbcli_state *cli)
 940 {
 941         NTSTATUS status;
 942         bool ret = true;
 943         union smb_open io;
 944         union smb_close cl;
 945         union smb_notify notify;
 946         struct smbcli_request *req;
 947         int fnum;
 948         const char *fname = BASEDIR "\\file.txt";
 949
 950         torture_comment(tctx, "TESTING CHANGE NOTIFY ON FILES\n");
 951
 952         torture_assert(tctx, torture_setup_dir(cli, BASEDIR),
 953                        "Failed to setup up test directory: " BASEDIR);
 954
 955         io.generic.level = RAW_OPEN_NTCREATEX;
 956         io.ntcreatex.in.root_fid.fnum = 0;
 957         io.ntcreatex.in.flags = 0;
 958         io.ntcreatex.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
 959         io.ntcreatex.in.create_options = 0;
 960         io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
 961         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ | NTCREATEX_SHARE_ACCESS_WRITE;
 962         io.ntcreatex.in.alloc_size = 0;
 963         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_CREATE;
 964         io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
 965         io.ntcreatex.in.security_flags = 0;
 966         io.ntcreatex.in.fname = fname;
 967         status = smb_raw_open(cli->tree, tctx, &io);
 968         torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
 969                                         "smb_raw_open");
 970         fnum = io.ntcreatex.out.file.fnum;
 971
 972         /* ask for a change notify,
 973            on file or directory name changes */
 974         notify.nttrans.level = RAW_NOTIFY_NTTRANS;
 975         notify.nttrans.in.file.fnum = fnum;
 976         notify.nttrans.in.buffer_size = 1000;
 977         notify.nttrans.in.completion_filter = FILE_NOTIFY_CHANGE_STREAM_NAME;
 978         notify.nttrans.in.recursive = false;
 979
 980         torture_comment(tctx, "Testing if notifies on file handles are invalid (should be)\n");
 981
 982         req = smb_raw_changenotify_send(cli->tree, &notify);
 983         status = smb_raw_changenotify_recv(req, tctx, &notify);
 984         torture_assert_ntstatus_equal_goto(tctx, status,
 985                                            NT_STATUS_INVALID_PARAMETER,
 986                                            ret, done,
 987                                            "smb_raw_changenotify_recv");
 988
 989         cl.close.level = RAW_CLOSE_CLOSE;
 990         cl.close.in.file.fnum = fnum;
 991         cl.close.in.write_time = 0;
 992         status = smb_raw_close(cli->tree, &cl);
 993         torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
 994                                         "smb_raw_close");
 995
 996         status = smbcli_unlink(cli->tree, fname);
 997         torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
 998                                         "smbcli_unlink");
 999
1000 done:
1001         smb_raw_exit(cli->session);
1002         smbcli_deltree(cli->tree, BASEDIR);
1003         return ret;
1004 }
1005
1006 /*
1007   basic testing of change notifies followed by a tdis
1008 */
1009 static bool test_notify_tdis(struct torture_context *tctx,
1010                              struct smbcli_state *cli1)
1011 {
1012         bool ret = true;
1013         NTSTATUS status;
1014         union smb_notify notify;
1015         union smb_open io;
1016         int fnum;
1017         struct smbcli_request *req;
1018         struct smbcli_state *cli = NULL;
1019
1020         torture_comment(tctx, "TESTING CHANGE NOTIFY FOLLOWED BY TDIS\n");
1021
1022         torture_assert(tctx, torture_setup_dir(cli1, BASEDIR),
1023                        "Failed to setup up test directory: " BASEDIR);
1024
1025         torture_assert(tctx, torture_open_connection(&cli, tctx, 0),
1026                        "Failed to open connection.");
1027
1028         /*
1029           get a handle on the directory
1030         */
1031         io.generic.level = RAW_OPEN_NTCREATEX;
1032         io.ntcreatex.in.root_fid.fnum = 0;
1033         io.ntcreatex.in.flags = 0;
1034         io.ntcreatex.in.access_mask = SEC_FILE_ALL;
1035         io.ntcreatex.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
1036         io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
1037         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ | NTCREATEX_SHARE_ACCESS_WRITE;
1038         io.ntcreatex.in.alloc_size = 0;
1039         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN;
1040         io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
1041         io.ntcreatex.in.security_flags = 0;
1042         io.ntcreatex.in.fname = BASEDIR;
1043
1044         status = smb_raw_open(cli->tree, tctx, &io);
1045         torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
1046                                         "smb_raw_open");
1047         fnum = io.ntcreatex.out.file.fnum;
1048
1049         /* ask for a change notify,
1050            on file or directory name changes */
1051         notify.nttrans.level = RAW_NOTIFY_NTTRANS;
1052         notify.nttrans.in.buffer_size = 1000;
1053         notify.nttrans.in.completion_filter = FILE_NOTIFY_CHANGE_NAME;
1054         notify.nttrans.in.file.fnum = fnum;
1055         notify.nttrans.in.recursive = true;
1056
1057         req = smb_raw_changenotify_send(cli->tree, &notify);
1058
1059         status = smbcli_tdis(cli);
1060         torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
1061                                         "smbcli_tdis");
1062         cli->tree = NULL;
1063
1064         status = smb_raw_changenotify_recv(req, tctx, &notify);
1065         torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
1066                                         "smb_raw_changenotify_recv");
1067         torture_assert_int_equal_goto(tctx, notify.nttrans.out.num_changes,
1068                                       0, ret, done, "no changes expected");
1069
1070 done:
1071         torture_close_connection(cli);
1072         smbcli_deltree(cli1->tree, BASEDIR);
1073         return ret;
1074 }
1075
1076 /*
1077   basic testing of change notifies followed by a exit
1078 */
1079 static bool test_notify_exit(struct torture_context *tctx,
1080                              struct smbcli_state *cli1)
1081 {
1082         bool ret = true;
1083         NTSTATUS status;
1084         union smb_notify notify;
1085         union smb_open io;
1086         int fnum;
1087         struct smbcli_request *req;
1088         struct smbcli_state *cli = NULL;
1089
1090         torture_comment(tctx, "TESTING CHANGE NOTIFY FOLLOWED BY EXIT\n");
1091
1092         torture_assert(tctx, torture_setup_dir(cli1, BASEDIR),
1093                        "Failed to setup up test directory: " BASEDIR);
1094
1095         torture_assert(tctx, torture_open_connection(&cli, tctx, 0),
1096                        "Failed to open connection.");
1097
1098         /*
1099           get a handle on the directory
1100         */
1101         io.generic.level = RAW_OPEN_NTCREATEX;
1102         io.ntcreatex.in.root_fid.fnum = 0;
1103         io.ntcreatex.in.flags = 0;
1104         io.ntcreatex.in.access_mask = SEC_FILE_ALL;
1105         io.ntcreatex.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
1106         io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
1107         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ | NTCREATEX_SHARE_ACCESS_WRITE;
1108         io.ntcreatex.in.alloc_size = 0;
1109         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN;
1110         io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
1111         io.ntcreatex.in.security_flags = 0;
1112         io.ntcreatex.in.fname = BASEDIR;
1113
1114         status = smb_raw_open(cli->tree, tctx, &io);
1115         torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
1116                                         "smb_raw_open");
1117         fnum = io.ntcreatex.out.file.fnum;
1118
1119         /* ask for a change notify,
1120            on file or directory name changes */
1121         notify.nttrans.level = RAW_NOTIFY_NTTRANS;
1122         notify.nttrans.in.buffer_size = 1000;
1123         notify.nttrans.in.completion_filter = FILE_NOTIFY_CHANGE_NAME;
1124         notify.nttrans.in.file.fnum = fnum;
1125         notify.nttrans.in.recursive = true;
1126
1127         req = smb_raw_changenotify_send(cli->tree, &notify);
1128
1129         status = smb_raw_exit(cli->session);
1130         torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
1131                                         "smb_raw_exit");
1132
1133         status = smb_raw_changenotify_recv(req, tctx, &notify);
1134         torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
1135                                         "smb_raw_changenotify_recv");
1136         torture_assert_int_equal_goto(tctx, notify.nttrans.out.num_changes,
1137                                       0, ret, done, "no changes expected");
1138
1139 done:
1140         torture_close_connection(cli);
1141         smbcli_deltree(cli1->tree, BASEDIR);
1142         return ret;
1143 }
1144
1145 /*
1146   basic testing of change notifies followed by a ulogoff
1147 */
1148 static bool test_notify_ulogoff(struct torture_context *tctx,
1149                                 struct smbcli_state *cli1)
1150 {
1151         bool ret = true;
1152         NTSTATUS status;
1153         union smb_notify notify;
1154         union smb_open io;
1155         int fnum;
1156         struct smbcli_request *req;
1157         struct smbcli_state *cli = NULL;
1158
1159         torture_comment(tctx, "TESTING CHANGE NOTIFY FOLLOWED BY ULOGOFF\n");
1160
1161         torture_assert(tctx, torture_setup_dir(cli1, BASEDIR),
1162                        "Failed to setup up test directory: " BASEDIR);
1163
1164         torture_assert(tctx, torture_open_connection(&cli, tctx, 0),
1165                        "Failed to open connection.");
1166
1167         /*
1168           get a handle on the directory
1169         */
1170         io.generic.level = RAW_OPEN_NTCREATEX;
1171         io.ntcreatex.in.root_fid.fnum = 0;
1172         io.ntcreatex.in.flags = 0;
1173         io.ntcreatex.in.access_mask = SEC_FILE_ALL;
1174         io.ntcreatex.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
1175         io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
1176         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ | NTCREATEX_SHARE_ACCESS_WRITE;
1177         io.ntcreatex.in.alloc_size = 0;
1178         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN;
1179         io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
1180         io.ntcreatex.in.security_flags = 0;
1181         io.ntcreatex.in.fname = BASEDIR;
1182
1183         status = smb_raw_open(cli->tree, tctx, &io);
1184         torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
1185                                         "smb_raw_open");
1186         fnum = io.ntcreatex.out.file.fnum;
1187
1188         /* ask for a change notify,
1189            on file or directory name changes */
1190         notify.nttrans.level = RAW_NOTIFY_NTTRANS;
1191         notify.nttrans.in.buffer_size = 1000;
1192         notify.nttrans.in.completion_filter = FILE_NOTIFY_CHANGE_NAME;
1193         notify.nttrans.in.file.fnum = fnum;
1194         notify.nttrans.in.recursive = true;
1195
1196         req = smb_raw_changenotify_send(cli->tree, &notify);
1197
1198         status = smb_raw_ulogoff(cli->session);
1199         torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
1200                                         "smb_raw_ulogoff");
1201
1202         status = smb_raw_changenotify_recv(req, tctx, &notify);
1203         torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
1204                                         "smb_raw_changenotify_recv");
1205         torture_assert_int_equal_goto(tctx, notify.nttrans.out.num_changes,
1206                                       0, ret, done, "no changes expected");
1207
1208 done:
1209         torture_close_connection(cli);
1210         smbcli_deltree(cli1->tree, BASEDIR);
1211         return ret;
1212 }
1213
1214 static void tcp_dis_handler(struct smbcli_transport *t, void *p)
1215 {
1216         struct smbcli_state *cli = (struct smbcli_state *)p;
1217         smbcli_transport_dead(cli->transport, NT_STATUS_LOCAL_DISCONNECT);
1218         cli->transport = NULL;
1219         cli->tree = NULL;
1220 }
1221 /*
1222   basic testing of change notifies followed by tcp disconnect
1223 */
1224 static bool test_notify_tcp_dis(struct torture_context *tctx,
1225                                 struct smbcli_state *cli1)
1226 {
1227         bool ret = true;
1228         NTSTATUS status;
1229         union smb_notify notify;
1230         union smb_open io;
1231         int fnum;
1232         struct smbcli_request *req;
1233         struct smbcli_state *cli = NULL;
1234
1235         torture_comment(tctx, "TESTING CHANGE NOTIFY FOLLOWED BY TCP DISCONNECT\n");
1236
1237         torture_assert(tctx, torture_setup_dir(cli1, BASEDIR),
1238                        "Failed to setup up test directory: " BASEDIR);
1239
1240         torture_assert(tctx, torture_open_connection(&cli, tctx, 0),
1241                        "Failed to open connection.");
1242
1243         /*
1244           get a handle on the directory
1245         */
1246         io.generic.level = RAW_OPEN_NTCREATEX;
1247         io.ntcreatex.in.root_fid.fnum = 0;
1248         io.ntcreatex.in.flags = 0;
1249         io.ntcreatex.in.access_mask = SEC_FILE_ALL;
1250         io.ntcreatex.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
1251         io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
1252         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ | NTCREATEX_SHARE_ACCESS_WRITE;
1253         io.ntcreatex.in.alloc_size = 0;
1254         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN;
1255         io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
1256         io.ntcreatex.in.security_flags = 0;
1257         io.ntcreatex.in.fname = BASEDIR;
1258
1259         status = smb_raw_open(cli->tree, tctx, &io);
1260         torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
1261                                         "smb_raw_open");
1262         fnum = io.ntcreatex.out.file.fnum;
1263
1264         /* ask for a change notify,
1265            on file or directory name changes */
1266         notify.nttrans.level = RAW_NOTIFY_NTTRANS;
1267         notify.nttrans.in.buffer_size = 1000;
1268         notify.nttrans.in.completion_filter = FILE_NOTIFY_CHANGE_NAME;
1269         notify.nttrans.in.file.fnum = fnum;
1270         notify.nttrans.in.recursive = true;
1271
1272         req = smb_raw_changenotify_send(cli->tree, &notify);
1273
1274         smbcli_transport_idle_handler(cli->transport, tcp_dis_handler, 250, cli);
1275
1276         status = smb_raw_changenotify_recv(req, tctx, &notify);
1277         torture_assert_ntstatus_equal_goto(tctx, status,
1278                                            NT_STATUS_LOCAL_DISCONNECT,
1279                                            ret, done,
1280                                            "smb_raw_changenotify_recv");
1281
1282 done:
1283         torture_close_connection(cli);
1284         smbcli_deltree(cli1->tree, BASEDIR);
1285         return ret;
1286 }
1287
1288 /*
1289    test setting up two change notify requests on one handle
1290 */
1291 static bool test_notify_double(struct torture_context *tctx,
1292                                struct smbcli_state *cli)
1293 {
1294         bool ret = true;
1295         NTSTATUS status;
1296         union smb_notify notify;
1297         union smb_open io;
1298         int fnum;
1299         struct smbcli_request *req1, *req2;
1300
1301         torture_comment(tctx, "TESTING CHANGE NOTIFY TWICE ON ONE DIRECTORY\n");
1302
1303         torture_assert(tctx, torture_setup_dir(cli, BASEDIR),
1304                        "Failed to setup up test directory: " BASEDIR);
1305
1306         /*
1307           get a handle on the directory
1308         */
1309         io.generic.level = RAW_OPEN_NTCREATEX;
1310         io.ntcreatex.in.root_fid.fnum = 0;
1311         io.ntcreatex.in.flags = 0;
1312         io.ntcreatex.in.access_mask = SEC_FILE_ALL;
1313         io.ntcreatex.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
1314         io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
1315         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ | NTCREATEX_SHARE_ACCESS_WRITE;
1316         io.ntcreatex.in.alloc_size = 0;
1317         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN;
1318         io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
1319         io.ntcreatex.in.security_flags = 0;
1320         io.ntcreatex.in.fname = BASEDIR;
1321
1322         status = smb_raw_open(cli->tree, tctx, &io);
1323         torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
1324                                         "smb_raw_open");
1325         fnum = io.ntcreatex.out.file.fnum;
1326
1327         /* ask for a change notify,
1328            on file or directory name changes */
1329         notify.nttrans.level = RAW_NOTIFY_NTTRANS;
1330         notify.nttrans.in.buffer_size = 1000;
1331         notify.nttrans.in.completion_filter = FILE_NOTIFY_CHANGE_NAME;
1332         notify.nttrans.in.file.fnum = fnum;
1333         notify.nttrans.in.recursive = true;
1334
1335         req1 = smb_raw_changenotify_send(cli->tree, &notify);
1336         req2 = smb_raw_changenotify_send(cli->tree, &notify);
1337
1338         smbcli_mkdir(cli->tree, BASEDIR "\\subdir-name");
1339
1340         status = smb_raw_changenotify_recv(req1, tctx, &notify);
1341         torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
1342                                         "smb_raw_changenotify_recv");
1343         torture_assert_int_equal_goto(tctx, notify.nttrans.out.num_changes,
1344                                       1, ret, done, "wrong number of changes");
1345         CHECK_WSTR(tctx, notify.nttrans.out.changes[0].name, "subdir-name",
1346                    STR_UNICODE);
1347
1348         smbcli_mkdir(cli->tree, BASEDIR "\\subdir-name2");
1349
1350         status = smb_raw_changenotify_recv(req2, tctx, &notify);
1351         torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
1352                                         "smb_raw_changenotify_recv");
1353         torture_assert_int_equal_goto(tctx, notify.nttrans.out.num_changes,
1354                                       1, ret, done, "wrong number of changes");
1355         CHECK_WSTR(tctx, notify.nttrans.out.changes[0].name, "subdir-name2",
1356                    STR_UNICODE);
1357
1358 done:
1359         smb_raw_exit(cli->session);
1360         smbcli_deltree(cli->tree, BASEDIR);
1361         return ret;
1362 }
1363
1364
1365 /*
1366    test multiple change notifies at different depths and with/without recursion
1367 */
1368 static bool test_notify_tree(struct torture_context *tctx,
1369                              struct smbcli_state *cli,
1370                              struct smbcli_state *cli2)
1371 {
1372         bool ret = true;
1373         union smb_notify notify;
1374         union smb_open io;
1375         struct smbcli_request *req;
1376         struct timeval tv;
1377         struct {
1378                 const char *path;
1379                 bool recursive;
1380                 uint32_t filter;
1381                 int expected;
1382                 int fnum;
1383                 int counted;
1384         } dirs[] = {
1385                 {BASEDIR "\\abc",               true, FILE_NOTIFY_CHANGE_NAME, 30 },
1386                 {BASEDIR "\\zqy",               true, FILE_NOTIFY_CHANGE_NAME, 8 },
1387                 {BASEDIR "\\atsy",              true, FILE_NOTIFY_CHANGE_NAME, 4 },
1388                 {BASEDIR "\\abc\\foo",          true,  FILE_NOTIFY_CHANGE_NAME, 2 },
1389                 {BASEDIR "\\abc\\blah",         true,  FILE_NOTIFY_CHANGE_NAME, 13 },
1390                 {BASEDIR "\\abc\\blah",         false, FILE_NOTIFY_CHANGE_NAME, 7 },
1391                 {BASEDIR "\\abc\\blah\\a",      true, FILE_NOTIFY_CHANGE_NAME, 2 },
1392                 {BASEDIR "\\abc\\blah\\b",      true, FILE_NOTIFY_CHANGE_NAME, 2 },
1393                 {BASEDIR "\\abc\\blah\\c",      true, FILE_NOTIFY_CHANGE_NAME, 2 },
1394                 {BASEDIR "\\abc\\fooblah",      true, FILE_NOTIFY_CHANGE_NAME, 2 },
1395                 {BASEDIR "\\zqy\\xx",           true, FILE_NOTIFY_CHANGE_NAME, 2 },
1396                 {BASEDIR "\\zqy\\yyy",          true, FILE_NOTIFY_CHANGE_NAME, 2 },
1397                 {BASEDIR "\\zqy\\..",           true, FILE_NOTIFY_CHANGE_NAME, 40 },
1398                 {BASEDIR,                       true, FILE_NOTIFY_CHANGE_NAME, 40 },
1399                 {BASEDIR,                       false,FILE_NOTIFY_CHANGE_NAME, 6 },
1400                 {BASEDIR "\\atsy",              false,FILE_NOTIFY_CHANGE_NAME, 4 },
1401                 {BASEDIR "\\abc",               true, FILE_NOTIFY_CHANGE_NAME, 24 },
1402                 {BASEDIR "\\abc",               false,FILE_NOTIFY_CHANGE_FILE_NAME, 0 },
1403                 {BASEDIR "\\abc",               true, FILE_NOTIFY_CHANGE_FILE_NAME, 0 },
1404                 {BASEDIR "\\abc",               true, FILE_NOTIFY_CHANGE_NAME, 24 },
1405         };
1406         int i;
1407         NTSTATUS status;
1408         bool all_done = false;
1409
1410         torture_comment(tctx, "TESTING CHANGE NOTIFY FOR DIFFERENT DEPTHS\n");
1411
1412         torture_assert(tctx, torture_setup_dir(cli, BASEDIR),
1413                        "Failed to setup up test directory: " BASEDIR);
1414
1415         io.generic.level = RAW_OPEN_NTCREATEX;
1416         io.ntcreatex.in.root_fid.fnum = 0;
1417         io.ntcreatex.in.flags = 0;
1418         io.ntcreatex.in.access_mask = SEC_FILE_ALL;
1419         io.ntcreatex.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
1420         io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
1421         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ | NTCREATEX_SHARE_ACCESS_WRITE;
1422         io.ntcreatex.in.alloc_size = 0;
1423         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN_IF;
1424         io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
1425         io.ntcreatex.in.security_flags = 0;
1426
1427         notify.nttrans.level = RAW_NOTIFY_NTTRANS;
1428         notify.nttrans.in.buffer_size = 20000;
1429
1430         /*
1431           setup the directory tree, and the notify buffer on each directory
1432         */
1433         for (i=0;i<ARRAY_SIZE(dirs);i++) {
1434                 io.ntcreatex.in.fname = dirs[i].path;
1435                 status = smb_raw_open(cli->tree, tctx, &io);
1436                 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
1437                                                 "smb_raw_open");
1438                 dirs[i].fnum = io.ntcreatex.out.file.fnum;
1439
1440                 notify.nttrans.in.completion_filter = dirs[i].filter;
1441                 notify.nttrans.in.file.fnum = dirs[i].fnum;
1442                 notify.nttrans.in.recursive = dirs[i].recursive;
1443                 req = smb_raw_changenotify_send(cli->tree, &notify);
1444                 smb_raw_ntcancel(req);
1445                 status = smb_raw_changenotify_recv(req, tctx, &notify);
1446                 torture_assert_ntstatus_equal_goto(tctx, status,
1447                                                    NT_STATUS_CANCELLED,
1448                                                    ret, done,
1449                                                    "smb_raw_changenotify_recv");
1450         }
1451
1452         /* trigger 2 events in each dir */
1453         for (i=0;i<ARRAY_SIZE(dirs);i++) {
1454                 char *path = talloc_asprintf(tctx, "%s\\test.dir", dirs[i].path);
1455                 /*
1456                  * Make notifies a bit more interesting in a cluster
1457                  * by doing the changes against different nodes with
1458                  * --unclist
1459                  */
1460                 smbcli_mkdir(cli->tree, path);
1461                 smbcli_rmdir(cli2->tree, path);
1462                 talloc_free(path);
1463         }
1464
1465         /* give a bit of time for the events to propogate */
1466         tv = timeval_current();
1467
1468         do {
1469                 /* count events that have happened in each dir */
1470                 for (i=0;i<ARRAY_SIZE(dirs);i++) {
1471                         notify.nttrans.in.file.fnum = dirs[i].fnum;
1472                         req = smb_raw_changenotify_send(cli->tree, &notify);
1473                         smb_raw_ntcancel(req);
1474                         notify.nttrans.out.num_changes = 0;
1475                         status = smb_raw_changenotify_recv(req, tctx, &notify);
1476                         dirs[i].counted += notify.nttrans.out.num_changes;
1477                 }
1478
1479                 all_done = true;
1480
1481                 for (i=0;i<ARRAY_SIZE(dirs);i++) {
1482                         if (dirs[i].counted != dirs[i].expected) {
1483                                 all_done = false;
1484                         }
1485                 }
1486         } while (!all_done && timeval_elapsed(&tv) < 20);
1487
1488         torture_comment(tctx, "took %.4f seconds to propogate all events\n", timeval_elapsed(&tv));
1489
1490         for (i=0;i<ARRAY_SIZE(dirs);i++) {
1491                 torture_assert_int_equal_goto(tctx,
1492                         dirs[i].counted, dirs[i].expected, ret, done,
1493                         talloc_asprintf(tctx,
1494                                         "unexpected number of events for '%s'",
1495                                         dirs[i].path));
1496         }
1497
1498         /*
1499           run from the back, closing and deleting
1500         */
1501         for (i=ARRAY_SIZE(dirs)-1;i>=0;i--) {
1502                 smbcli_close(cli->tree, dirs[i].fnum);
1503                 smbcli_rmdir(cli->tree, dirs[i].path);
1504         }
1505
1506 done:
1507         smb_raw_exit(cli->session);
1508         smbcli_deltree(cli->tree, BASEDIR);
1509         return ret;
1510 }
1511
1512 /*
1513    Test response when cached server events exceed single NT NOTFIY response
1514    packet size.
1515 */
1516 static bool test_notify_overflow(struct torture_context *tctx,
1517                                  struct smbcli_state *cli)
1518 {
1519         bool ret = true;
1520         NTSTATUS status;
1521         union smb_notify notify;
1522         union smb_open io;
1523         int fnum;
1524         int count = 100;
1525         struct smbcli_request *req1;
1526         int i;
1527
1528         torture_comment(tctx, "TESTING CHANGE NOTIFY EVENT OVERFLOW\n");
1529
1530         torture_assert(tctx, torture_setup_dir(cli, BASEDIR),
1531                        "Failed to setup up test directory: " BASEDIR);
1532
1533         /* get a handle on the directory */
1534         io.generic.level = RAW_OPEN_NTCREATEX;
1535         io.ntcreatex.in.root_fid.fnum = 0;
1536         io.ntcreatex.in.flags = 0;
1537         io.ntcreatex.in.access_mask = SEC_FILE_ALL;
1538         io.ntcreatex.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
1539         io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
1540         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
1541             NTCREATEX_SHARE_ACCESS_WRITE;
1542         io.ntcreatex.in.alloc_size = 0;
1543         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN;
1544         io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
1545         io.ntcreatex.in.security_flags = 0;
1546         io.ntcreatex.in.fname = BASEDIR;
1547
1548         status = smb_raw_open(cli->tree, tctx, &io);
1549         torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
1550                                         "smb_raw_open");
1551         fnum = io.ntcreatex.out.file.fnum;
1552
1553         /* ask for a change notify, on name changes. */
1554         notify.nttrans.level = RAW_NOTIFY_NTTRANS;
1555         notify.nttrans.in.buffer_size = 1000;
1556         notify.nttrans.in.completion_filter = FILE_NOTIFY_CHANGE_NAME;
1557         notify.nttrans.in.file.fnum = fnum;
1558
1559         notify.nttrans.in.recursive = true;
1560         req1 = smb_raw_changenotify_send(cli->tree, &notify);
1561
1562         /* cancel initial requests so the buffer is setup */
1563         smb_raw_ntcancel(req1);
1564         status = smb_raw_changenotify_recv(req1, tctx, &notify);
1565         torture_assert_ntstatus_equal_goto(tctx, status,
1566                                            NT_STATUS_CANCELLED,
1567                                            ret, done,
1568                                            "smb_raw_changenotify_recv");
1569
1570         /* open a lot of files, filling up the server side notify buffer */
1571         torture_comment(tctx, "Testing overflowed buffer notify on create of %d files\n",
1572                count);
1573         for (i=0;i<count;i++) {
1574                 char *fname = talloc_asprintf(cli, BASEDIR "\\test%d.txt", i);
1575                 int fnum2 = smbcli_open(cli->tree, fname, O_CREAT|O_RDWR,
1576                                         DENY_NONE);
1577                 torture_assert_int_not_equal_goto(tctx, fnum2, -1, ret, done,
1578                         talloc_asprintf(tctx, "Failed to create %s - %s",
1579                                         fname, smbcli_errstr(cli->tree)));
1580                 talloc_free(fname);
1581                 smbcli_close(cli->tree, fnum2);
1582         }
1583
1584         /* expect that 0 events will be returned with NT_STATUS_OK */
1585         req1 = smb_raw_changenotify_send(cli->tree, &notify);
1586         status = smb_raw_changenotify_recv(req1, tctx, &notify);
1587         torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
1588                                         "smb_raw_changenotify_recv");
1589         torture_assert_int_equal_goto(tctx, notify.nttrans.out.num_changes,
1590                                       0, ret, done, "no changes expected");
1591
1592 done:
1593         smb_raw_exit(cli->session);
1594         smbcli_deltree(cli->tree, BASEDIR);
1595         return ret;
1596 }
1597
1598 /*
1599    Test if notifications are returned for changes to the base directory.
1600    They shouldn't be.
1601 */
1602 static bool test_notify_basedir(struct torture_context *tctx,
1603                                 struct smbcli_state *cli)
1604 {
1605         bool ret = true;
1606         NTSTATUS status;
1607         union smb_notify notify;
1608         union smb_open io;
1609         int fnum;
1610         struct smbcli_request *req1;
1611
1612         torture_comment(tctx, "TESTING CHANGE NOTIFY BASEDIR EVENTS\n");
1613
1614         torture_assert(tctx, torture_setup_dir(cli, BASEDIR),
1615                        "Failed to setup up test directory: " BASEDIR);
1616
1617         /* get a handle on the directory */
1618         io.generic.level = RAW_OPEN_NTCREATEX;
1619         io.ntcreatex.in.root_fid.fnum = 0;
1620         io.ntcreatex.in.flags = 0;
1621         io.ntcreatex.in.access_mask = SEC_FILE_ALL;
1622         io.ntcreatex.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
1623         io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
1624         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
1625             NTCREATEX_SHARE_ACCESS_WRITE;
1626         io.ntcreatex.in.alloc_size = 0;
1627         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN;
1628         io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
1629         io.ntcreatex.in.security_flags = 0;
1630         io.ntcreatex.in.fname = BASEDIR;
1631
1632         status = smb_raw_open(cli->tree, tctx, &io);
1633         torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
1634                                         "smb_raw_open");
1635         fnum = io.ntcreatex.out.file.fnum;
1636
1637         /* create a test file that will also be modified */
1638         smbcli_close(cli->tree, smbcli_open(cli->tree, BASEDIR "\\tname1",
1639                                             O_CREAT, 0));
1640
1641         /* ask for a change notify, on attribute changes. */
1642         notify.nttrans.level = RAW_NOTIFY_NTTRANS;
1643         notify.nttrans.in.buffer_size = 1000;
1644         notify.nttrans.in.completion_filter = FILE_NOTIFY_CHANGE_ATTRIBUTES;
1645         notify.nttrans.in.file.fnum = fnum;
1646         notify.nttrans.in.recursive = true;
1647
1648         req1 = smb_raw_changenotify_send(cli->tree, &notify);
1649
1650         /* set attribute on the base dir */
1651         smbcli_setatr(cli->tree, BASEDIR, FILE_ATTRIBUTE_HIDDEN, 0);
1652
1653         /* set attribute on a file to assure we receive a notification */
1654         smbcli_setatr(cli->tree, BASEDIR "\\tname1", FILE_ATTRIBUTE_HIDDEN, 0);
1655         smb_msleep(200);
1656
1657         /* check how many responses were given, expect only 1 for the file */
1658         status = smb_raw_changenotify_recv(req1, tctx, &notify);
1659         torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
1660                                         "smb_raw_changenotify_recv");
1661         torture_assert_int_equal_goto(tctx, notify.nttrans.out.num_changes,
1662                                       1, ret, done, "wrong number of  changes");
1663         torture_assert_int_equal_goto(tctx,
1664                                       notify.nttrans.out.changes[0].action,
1665                                       NOTIFY_ACTION_MODIFIED, ret, done,
1666                                       "wrong action (exp: MODIFIED)");
1667         CHECK_WSTR(tctx, notify.nttrans.out.changes[0].name, "tname1",
1668                    STR_UNICODE);
1669
1670 done:
1671         smb_raw_exit(cli->session);
1672         smbcli_deltree(cli->tree, BASEDIR);
1673         return ret;
1674 }
1675
1676
1677 /*
1678   create a secondary tree connect - used to test for a bug in Samba3 messaging
1679   with change notify
1680 */
1681 static struct smbcli_tree *secondary_tcon(struct smbcli_state *cli,
1682                                           struct torture_context *tctx)
1683 {
1684         NTSTATUS status;
1685         const char *share, *host;
1686         struct smbcli_tree *tree;
1687         union smb_tcon tcon;
1688
1689         share = torture_setting_string(tctx, "share", NULL);
1690         host  = torture_setting_string(tctx, "host", NULL);
1691
1692         torture_comment(tctx, "create a second tree context on the same session\n");
1693         tree = smbcli_tree_init(cli->session, tctx, false);
1694
1695         tcon.generic.level = RAW_TCON_TCONX;
1696         tcon.tconx.in.flags = TCONX_FLAG_EXTENDED_RESPONSE;
1697         tcon.tconx.in.password = data_blob(NULL, 0);
1698         tcon.tconx.in.path = talloc_asprintf(tctx, "\\\\%s\\%s", host, share);
1699         tcon.tconx.in.device = "A:";
1700         status = smb_raw_tcon(tree, tctx, &tcon);
1701         if (!NT_STATUS_IS_OK(status)) {
1702                 talloc_free(tree);
1703                 torture_comment(tctx, "Failed to create secondary tree\n");
1704                 return NULL;
1705         }
1706
1707         tree->tid = tcon.tconx.out.tid;
1708         torture_comment(tctx, "tid1=%d tid2=%d\n", cli->tree->tid, tree->tid);
1709
1710         return tree;
1711 }
1712
1713
1714 /*
1715    very simple change notify test
1716 */
1717 static bool test_notify_tcon(struct torture_context *tctx,
1718                              struct smbcli_state *cli)
1719 {
1720         bool ret = true;
1721         NTSTATUS status;
1722         union smb_notify notify;
1723         union smb_open io;
1724         int fnum;
1725         struct smbcli_request *req;
1726         extern int torture_numops;
1727         struct smbcli_tree *tree = NULL;
1728
1729         torture_comment(tctx, "TESTING SIMPLE CHANGE NOTIFY\n");
1730
1731         torture_assert(tctx, torture_setup_dir(cli, BASEDIR),
1732                        "Failed to setup up test directory: " BASEDIR);
1733
1734         /*
1735           get a handle on the directory
1736         */
1737         io.generic.level = RAW_OPEN_NTCREATEX;
1738         io.ntcreatex.in.root_fid.fnum = 0;
1739         io.ntcreatex.in.flags = 0;
1740         io.ntcreatex.in.access_mask = SEC_FILE_ALL;
1741         io.ntcreatex.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
1742         io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
1743         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ | NTCREATEX_SHARE_ACCESS_WRITE;
1744         io.ntcreatex.in.alloc_size = 0;
1745         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN;
1746         io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
1747         io.ntcreatex.in.security_flags = 0;
1748         io.ntcreatex.in.fname = BASEDIR;
1749
1750         status = smb_raw_open(cli->tree, tctx, &io);
1751         torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
1752                                         "smb_raw_open");
1753         fnum = io.ntcreatex.out.file.fnum;
1754
1755         status = smb_raw_open(cli->tree, tctx, &io);
1756         torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
1757                                         "smb_raw_open");
1758
1759         /* ask for a change notify,
1760            on file or directory name changes */
1761         notify.nttrans.level = RAW_NOTIFY_NTTRANS;
1762         notify.nttrans.in.buffer_size = 1000;
1763         notify.nttrans.in.completion_filter = FILE_NOTIFY_CHANGE_NAME;
1764         notify.nttrans.in.file.fnum = fnum;
1765         notify.nttrans.in.recursive = true;
1766
1767         torture_comment(tctx, "Testing notify mkdir\n");
1768         req = smb_raw_changenotify_send(cli->tree, &notify);
1769         smbcli_mkdir(cli->tree, BASEDIR "\\subdir-name");
1770
1771         status = smb_raw_changenotify_recv(req, tctx, &notify);
1772         torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
1773                                         "smb_raw_changenotify_recv");
1774
1775         torture_assert_int_equal_goto(tctx, notify.nttrans.out.num_changes,
1776                                       1, ret, done, "wrong number of changes");
1777         torture_assert_int_equal_goto(tctx,
1778                                       notify.nttrans.out.changes[0].action,
1779                                       NOTIFY_ACTION_ADDED, ret, done,
1780                                       "wrong action (exp: ADDED)");
1781         CHECK_WSTR(tctx, notify.nttrans.out.changes[0].name, "subdir-name",
1782                    STR_UNICODE);
1783
1784         torture_comment(tctx, "Testing notify rmdir\n");
1785         req = smb_raw_changenotify_send(cli->tree, &notify);
1786         smbcli_rmdir(cli->tree, BASEDIR "\\subdir-name");
1787
1788         status = smb_raw_changenotify_recv(req, tctx, &notify);
1789         torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
1790                                         "smb_raw_changenotify_recv");
1791         torture_assert_int_equal_goto(tctx, notify.nttrans.out.num_changes,
1792                                       1, ret, done, "wrong number of changes");
1793         torture_assert_int_equal_goto(tctx,
1794                                       notify.nttrans.out.changes[0].action,
1795                                       NOTIFY_ACTION_REMOVED, ret, done,
1796                                       "wrong action (exp: REMOVED)");
1797         CHECK_WSTR(tctx, notify.nttrans.out.changes[0].name, "subdir-name",
1798                    STR_UNICODE);
1799
1800         torture_comment(tctx, "SIMPLE CHANGE NOTIFY OK\n");
1801
1802         torture_comment(tctx, "TESTING WITH SECONDARY TCON\n");
1803         tree = secondary_tcon(cli, tctx);
1804         torture_assert_not_null_goto(tctx, tree, ret, done,
1805                                      "failed to create secondary tcon");
1806
1807         torture_comment(tctx, "Testing notify mkdir\n");
1808         req = smb_raw_changenotify_send(cli->tree, &notify);
1809         smbcli_mkdir(cli->tree, BASEDIR "\\subdir-name");
1810
1811         status = smb_raw_changenotify_recv(req, tctx, &notify);
1812         torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
1813                                         "smb_raw_changenotify_recv");
1814
1815         torture_assert_int_equal_goto(tctx, notify.nttrans.out.num_changes,
1816                                       1, ret, done, "wrong number of changes");
1817         torture_assert_int_equal_goto(tctx,
1818                                       notify.nttrans.out.changes[0].action,
1819                                       NOTIFY_ACTION_ADDED, ret, done,
1820                                       "wrong action (exp: ADDED)");
1821         CHECK_WSTR(tctx, notify.nttrans.out.changes[0].name, "subdir-name",
1822                    STR_UNICODE);
1823
1824         torture_comment(tctx, "Testing notify rmdir\n");
1825         req = smb_raw_changenotify_send(cli->tree, &notify);
1826         smbcli_rmdir(cli->tree, BASEDIR "\\subdir-name");
1827
1828         status = smb_raw_changenotify_recv(req, tctx, &notify);
1829         torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
1830                                         "smb_raw_changenotify_recv");
1831         torture_assert_int_equal_goto(tctx, notify.nttrans.out.num_changes,
1832                                       1, ret, done, "wrong number of changes");
1833         torture_assert_int_equal_goto(tctx,
1834                                       notify.nttrans.out.changes[0].action,
1835                                       NOTIFY_ACTION_REMOVED, ret, done,
1836                                       "wrong action (exp: REMOVED)");
1837         CHECK_WSTR(tctx, notify.nttrans.out.changes[0].name, "subdir-name",
1838                    STR_UNICODE);
1839
1840         torture_comment(tctx, "CHANGE NOTIFY WITH TCON OK\n");
1841
1842         torture_comment(tctx, "Disconnecting secondary tree\n");
1843         status = smb_tree_disconnect(tree);
1844         torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
1845                                         "smb_tree_disconnect");
1846         talloc_free(tree);
1847
1848         torture_comment(tctx, "Testing notify mkdir\n");
1849         req = smb_raw_changenotify_send(cli->tree, &notify);
1850         smbcli_mkdir(cli->tree, BASEDIR "\\subdir-name");
1851
1852         status = smb_raw_changenotify_recv(req, tctx, &notify);
1853         torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
1854                                         "smb_raw_changenotify_recv");
1855
1856         torture_assert_int_equal_goto(tctx, notify.nttrans.out.num_changes,
1857                                       1, ret, done, "wrong number of changes");
1858         torture_assert_int_equal_goto(tctx,
1859                                       notify.nttrans.out.changes[0].action,
1860                                       NOTIFY_ACTION_ADDED, ret, done,
1861                                       "wrong action (exp: ADDED)");
1862         CHECK_WSTR(tctx, notify.nttrans.out.changes[0].name, "subdir-name",
1863                    STR_UNICODE);
1864
1865         torture_comment(tctx, "Testing notify rmdir\n");
1866         req = smb_raw_changenotify_send(cli->tree, &notify);
1867         smbcli_rmdir(cli->tree, BASEDIR "\\subdir-name");
1868
1869         status = smb_raw_changenotify_recv(req, tctx, &notify);
1870         torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
1871                                         "smb_raw_changenotify_recv");
1872         torture_assert_int_equal_goto(tctx, notify.nttrans.out.num_changes,
1873                                       1, ret, done, "wrong number of changes");
1874         torture_assert_int_equal_goto(tctx,
1875                                       notify.nttrans.out.changes[0].action,
1876                                       NOTIFY_ACTION_REMOVED, ret, done,
1877                                       "wrong action (exp: REMOVED)");
1878         CHECK_WSTR(tctx, notify.nttrans.out.changes[0].name, "subdir-name",
1879                    STR_UNICODE);
1880
1881         torture_comment(tctx, "CHANGE NOTIFY WITH TDIS OK\n");
1882 done:
1883         smb_raw_exit(cli->session);
1884         smbcli_deltree(cli->tree, BASEDIR);
1885         return ret;
1886 }
1887
1888
1889 /*
1890    testing alignment of multiple change notify infos
1891 */
1892 static bool test_notify_alignment(struct torture_context *tctx,
1893                                   struct smbcli_state *cli)
1894 {
1895         NTSTATUS status;
1896         union smb_notify notify;
1897         union smb_open io;
1898         int i, fnum, fnum2;
1899         struct smbcli_request *req;
1900         const char *fname = BASEDIR "\\starter";
1901         const char *fnames[] = { "a",
1902                                  "ab",
1903                                  "abc",
1904                                  "abcd" };
1905         int num_names = ARRAY_SIZE(fnames);
1906         char *fpath = NULL;
1907
1908         torture_comment(tctx, "TESTING CHANGE NOTIFY REPLY ALIGNMENT\n");
1909
1910         torture_assert(tctx, torture_setup_dir(cli, BASEDIR),
1911                        "Failed to setup up test directory: " BASEDIR);
1912
1913         /* get a handle on the directory */
1914         io.generic.level = RAW_OPEN_NTCREATEX;
1915         io.ntcreatex.in.root_fid.fnum = 0;
1916         io.ntcreatex.in.flags = 0;
1917         io.ntcreatex.in.access_mask = SEC_FILE_ALL;
1918         io.ntcreatex.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
1919         io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
1920         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
1921                                        NTCREATEX_SHARE_ACCESS_WRITE;
1922         io.ntcreatex.in.alloc_size = 0;
1923         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN;
1924         io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
1925         io.ntcreatex.in.security_flags = 0;
1926         io.ntcreatex.in.fname = BASEDIR;
1927
1928         status = smb_raw_open(cli->tree, tctx, &io);
1929         torture_assert_ntstatus_ok(tctx, status, "smb_raw_open");
1930         fnum = io.ntcreatex.out.file.fnum;
1931
1932         /* ask for a change notify, on file creation */
1933         notify.nttrans.level = RAW_NOTIFY_NTTRANS;
1934         notify.nttrans.in.buffer_size = 1000;
1935         notify.nttrans.in.completion_filter = FILE_NOTIFY_CHANGE_FILE_NAME;
1936         notify.nttrans.in.file.fnum = fnum;
1937         notify.nttrans.in.recursive = false;
1938
1939         /* start change tracking */
1940         req = smb_raw_changenotify_send(cli->tree, &notify);
1941
1942         fnum2 = smbcli_open(cli->tree, fname, O_CREAT|O_RDWR, DENY_NONE);
1943         torture_assert(tctx, fnum2 != -1, smbcli_errstr(cli->tree));
1944         smbcli_close(cli->tree, fnum2);
1945
1946         status = smb_raw_changenotify_recv(req, tctx, &notify);
1947         torture_assert_ntstatus_ok(tctx, status, "smb_raw_changenotify_recv");
1948
1949         /* create 4 files that will cause CHANGE_NOTIFY_INFO structures
1950          * to be returned in the same packet with all possible 4-byte padding
1951          * permutations.  As per MS-CIFS 2.2.7.4.2 these structures should be
1952          * 4-byte aligned. */
1953
1954         for (i = 0; i < num_names; i++) {
1955                 fpath = talloc_asprintf(tctx, "%s\\%s", BASEDIR, fnames[i]);
1956                 fnum2 = smbcli_open(cli->tree, fpath,
1957                     O_CREAT|O_RDWR, DENY_NONE);
1958                 torture_assert(tctx, fnum2 != -1, smbcli_errstr(cli->tree));
1959                 smbcli_close(cli->tree, fnum2);
1960                 talloc_free(fpath);
1961         }
1962
1963         /* We send a notify packet, and let smb_raw_changenotify_recv() do
1964          * the alignment checking for us. */
1965         req = smb_raw_changenotify_send(cli->tree, &notify);
1966         status = smb_raw_changenotify_recv(req, tctx, &notify);
1967         torture_assert_ntstatus_ok(tctx, status, "smb_raw_changenotify_recv");
1968
1969         /* Do basic checking for correctness. */
1970         torture_assert(tctx, notify.nttrans.out.num_changes == num_names, "");
1971         for (i = 0; i < num_names; i++) {
1972                 torture_assert(tctx, notify.nttrans.out.changes[i].action ==
1973                     NOTIFY_ACTION_ADDED, "");
1974                 CHECK_WSTR(tctx, notify.nttrans.out.changes[i].name, fnames[i],
1975                     STR_UNICODE);
1976         }
1977
1978         smb_raw_exit(cli->session);
1979         smbcli_deltree(cli->tree, BASEDIR);
1980         return true;
1981 }
1982
1983 struct torture_suite *torture_raw_notify(TALLOC_CTX *mem_ctx)
1984 {
1985         struct torture_suite *suite = torture_suite_create(mem_ctx, "notify");
1986
1987         torture_suite_add_1smb_test(suite, "tcon", test_notify_tcon);
1988         torture_suite_add_2smb_test(suite, "dir", test_notify_dir);
1989         torture_suite_add_2smb_test(suite, "mask", test_notify_mask);
1990         torture_suite_add_2smb_test(suite, "recursive", test_notify_recursive);
1991         torture_suite_add_1smb_test(suite, "mask_change",
1992                                     test_notify_mask_change);
1993         torture_suite_add_1smb_test(suite, "file", test_notify_file);
1994         torture_suite_add_1smb_test(suite, "tdis", test_notify_tdis);
1995         torture_suite_add_1smb_test(suite, "exit", test_notify_exit);
1996         torture_suite_add_1smb_test(suite, "ulogoff", test_notify_ulogoff);
1997         torture_suite_add_1smb_test(suite, "tcp_dis", test_notify_tcp_dis);
1998         torture_suite_add_1smb_test(suite, "double", test_notify_double);
1999         torture_suite_add_2smb_test(suite, "tree", test_notify_tree);
2000         torture_suite_add_1smb_test(suite, "overflow", test_notify_overflow);
2001         torture_suite_add_1smb_test(suite, "basedir", test_notify_basedir);
2002         torture_suite_add_1smb_test(suite, "alignment", test_notify_alignment);
2003
2004         return suite;
2005 }