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