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