source/torture/basic/locking.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    basic locking tests
   5
   6    Copyright (C) Andrew Tridgell 2000-2004
   7    Copyright (C) Jeremy Allison 2000-2004
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 2 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program; if not, write to the Free Software
  21    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  22 */
  23
  24 #include "includes.h"
  25 #include "libcli/raw/libcliraw.h"
  26 #include "system/time.h"
  27
  28 #define BASEDIR "\\locktest"
  29
  30 /*
  31   This test checks for two things:
  32
  33   1) correct support for retaining locks over a close (ie. the server
  34      must not use posix semantics)
  35   2) support for lock timeouts
  36  */
  37 BOOL torture_locktest1(void)
  38 {
  39         struct smbcli_state *cli1, *cli2;
  40         const char *fname = BASEDIR "\\lockt1.lck";
  41         int fnum1, fnum2, fnum3;
  42         time_t t1, t2;
  43         uint_t lock_timeout;
  44
  45         if (!torture_open_connection(&cli1) || !torture_open_connection(&cli2)) {
  46                 return False;
  47         }
  48
  49         printf("starting locktest1\n");
  50
  51         if (!torture_setup_dir(cli1, BASEDIR)) {
  52                 return False;
  53         }
  54
  55         fnum1 = smbcli_open(cli1->tree, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
  56         if (fnum1 == -1) {
  57                 printf("open of %s failed (%s)\n", fname, smbcli_errstr(cli1->tree));
  58                 return False;
  59         }
  60         fnum2 = smbcli_open(cli1->tree, fname, O_RDWR, DENY_NONE);
  61         if (fnum2 == -1) {
  62                 printf("(%s) open2 of %s failed (%s)\n",
  63                        __location__, fname, smbcli_errstr(cli1->tree));
  64                 return False;
  65         }
  66         fnum3 = smbcli_open(cli2->tree, fname, O_RDWR, DENY_NONE);
  67         if (fnum3 == -1) {
  68                 printf("open3 of %s failed (%s)\n", fname, smbcli_errstr(cli2->tree));
  69                 return False;
  70         }
  71
  72         if (NT_STATUS_IS_ERR(smbcli_lock(cli1->tree, fnum1, 0, 4, 0, WRITE_LOCK))) {
  73                 printf("lock1 failed (%s)\n", smbcli_errstr(cli1->tree));
  74                 return False;
  75         }
  76
  77
  78         if (NT_STATUS_IS_OK(smbcli_lock(cli2->tree, fnum3, 0, 4, 0, WRITE_LOCK))) {
  79                 printf("lock2 succeeded! This is a locking bug\n");
  80                 return False;
  81         } else {
  82                 if (!check_error(__location__, cli2, ERRDOS, ERRlock,
  83                                  NT_STATUS_LOCK_NOT_GRANTED)) return False;
  84         }
  85
  86         if (NT_STATUS_IS_OK(smbcli_lock(cli2->tree, fnum3, 0, 4, 0, WRITE_LOCK))) {
  87                 printf("lock2 succeeded! This is a locking bug\n");
  88                 return False;
  89         } else {
  90                 if (!check_error(__location__, cli2, ERRDOS, ERRlock,
  91                                  NT_STATUS_FILE_LOCK_CONFLICT)) return False;
  92         }
  93
  94         if (NT_STATUS_IS_ERR(smbcli_lock(cli1->tree, fnum1, 5, 9, 0, WRITE_LOCK))) {
  95                 printf("lock1 failed (%s)\n", smbcli_errstr(cli1->tree));
  96                 return False;
  97         }
  98
  99         if (NT_STATUS_IS_OK(smbcli_lock(cli2->tree, fnum3, 5, 9, 0, WRITE_LOCK))) {
 100                 printf("lock2 succeeded! This is a locking bug\n");
 101                 return False;
 102         } else {
 103                 if (!check_error(__location__, cli2, ERRDOS, ERRlock,
 104                                  NT_STATUS_LOCK_NOT_GRANTED)) return False;
 105         }
 106
 107         if (NT_STATUS_IS_OK(smbcli_lock(cli2->tree, fnum3, 0, 4, 0, WRITE_LOCK))) {
 108                 printf("lock2 succeeded! This is a locking bug\n");
 109                 return False;
 110         } else {
 111                 if (!check_error(__location__, cli2, ERRDOS, ERRlock,
 112                                  NT_STATUS_LOCK_NOT_GRANTED)) return False;
 113         }
 114
 115         if (NT_STATUS_IS_OK(smbcli_lock(cli2->tree, fnum3, 0, 4, 0, WRITE_LOCK))) {
 116                 printf("lock2 succeeded! This is a locking bug\n");
 117                 return False;
 118         } else {
 119                 if (!check_error(__location__, cli2, ERRDOS, ERRlock,
 120                                  NT_STATUS_FILE_LOCK_CONFLICT)) return False;
 121         }
 122
 123         lock_timeout = (6 + (random() % 20));
 124         printf("Testing lock timeout with timeout=%u\n", lock_timeout);
 125         t1 = time(NULL);
 126         if (NT_STATUS_IS_OK(smbcli_lock(cli2->tree, fnum3, 0, 4, lock_timeout * 1000, WRITE_LOCK))) {
 127                 printf("lock3 succeeded! This is a locking bug\n");
 128                 return False;
 129         } else {
 130                 if (!check_error(__location__, cli2, ERRDOS, ERRlock,
 131                                  NT_STATUS_FILE_LOCK_CONFLICT)) return False;
 132         }
 133         t2 = time(NULL);
 134
 135         if (t2 - t1 < 5) {
 136                 printf("error: This server appears not to support timed lock requests\n");
 137         }
 138         printf("server slept for %u seconds for a %u second timeout\n",
 139                (uint_t)(t2-t1), lock_timeout);
 140
 141         if (NT_STATUS_IS_ERR(smbcli_close(cli1->tree, fnum2))) {
 142                 printf("close1 failed (%s)\n", smbcli_errstr(cli1->tree));
 143                 return False;
 144         }
 145
 146         if (NT_STATUS_IS_OK(smbcli_lock(cli2->tree, fnum3, 0, 4, 0, WRITE_LOCK))) {
 147                 printf("lock4 succeeded! This is a locking bug\n");
 148                 return False;
 149         } else {
 150                 if (!check_error(__location__, cli2, ERRDOS, ERRlock,
 151                                  NT_STATUS_FILE_LOCK_CONFLICT)) return False;
 152         }
 153
 154         if (NT_STATUS_IS_ERR(smbcli_close(cli1->tree, fnum1))) {
 155                 printf("close2 failed (%s)\n", smbcli_errstr(cli1->tree));
 156                 return False;
 157         }
 158
 159         if (NT_STATUS_IS_ERR(smbcli_close(cli2->tree, fnum3))) {
 160                 printf("close3 failed (%s)\n", smbcli_errstr(cli2->tree));
 161                 return False;
 162         }
 163
 164         if (NT_STATUS_IS_ERR(smbcli_unlink(cli1->tree, fname))) {
 165                 printf("unlink failed (%s)\n", smbcli_errstr(cli1->tree));
 166                 return False;
 167         }
 168
 169
 170         if (!torture_close_connection(cli1)) {
 171                 return False;
 172         }
 173
 174         if (!torture_close_connection(cli2)) {
 175                 return False;
 176         }
 177
 178         printf("Passed locktest1\n");
 179         return True;
 180 }
 181
 182
 183 /*
 184   This test checks that
 185
 186   1) the server supports multiple locking contexts on the one SMB
 187   connection, distinguished by PID.
 188
 189   2) the server correctly fails overlapping locks made by the same PID (this
 190      goes against POSIX behaviour, which is why it is tricky to implement)
 191
 192   3) the server denies unlock requests by an incorrect client PID
 193 */
 194 BOOL torture_locktest2(void)
 195 {
 196         struct smbcli_state *cli;
 197         const char *fname = BASEDIR "\\lockt2.lck";
 198         int fnum1, fnum2, fnum3;
 199         BOOL correct = True;
 200
 201         if (!torture_open_connection(&cli)) {
 202                 return False;
 203         }
 204
 205         printf("starting locktest2\n");
 206
 207         if (!torture_setup_dir(cli, BASEDIR)) {
 208                 return False;
 209         }
 210
 211         printf("Testing pid context\n");
 212
 213         cli->session->pid = 1;
 214
 215         fnum1 = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
 216         if (fnum1 == -1) {
 217                 printf("open of %s failed (%s)\n", fname, smbcli_errstr(cli->tree));
 218                 return False;
 219         }
 220
 221         fnum2 = smbcli_open(cli->tree, fname, O_RDWR, DENY_NONE);
 222         if (fnum2 == -1) {
 223                 printf("(%s) open2 of %s failed (%s)\n",
 224                        __location__, fname, smbcli_errstr(cli->tree));
 225                 return False;
 226         }
 227
 228         cli->session->pid = 2;
 229
 230         fnum3 = smbcli_open(cli->tree, fname, O_RDWR, DENY_NONE);
 231         if (fnum3 == -1) {
 232                 printf("open3 of %s failed (%s)\n", fname, smbcli_errstr(cli->tree));
 233                 return False;
 234         }
 235
 236         cli->session->pid = 1;
 237
 238         if (NT_STATUS_IS_ERR(smbcli_lock(cli->tree, fnum1, 0, 4, 0, WRITE_LOCK))) {
 239                 printf("lock1 failed (%s)\n", smbcli_errstr(cli->tree));
 240                 return False;
 241         }
 242
 243         if (NT_STATUS_IS_OK(smbcli_lock(cli->tree, fnum1, 0, 4, 0, WRITE_LOCK))) {
 244                 printf("WRITE lock1 succeeded! This is a locking bug\n");
 245                 correct = False;
 246         } else {
 247                 if (!check_error(__location__, cli, ERRDOS, ERRlock,
 248                                  NT_STATUS_LOCK_NOT_GRANTED)) return False;
 249         }
 250
 251         if (NT_STATUS_IS_OK(smbcli_lock(cli->tree, fnum2, 0, 4, 0, WRITE_LOCK))) {
 252                 printf("WRITE lock2 succeeded! This is a locking bug\n");
 253                 correct = False;
 254         } else {
 255                 if (!check_error(__location__, cli, ERRDOS, ERRlock,
 256                                  NT_STATUS_LOCK_NOT_GRANTED)) return False;
 257         }
 258
 259         if (NT_STATUS_IS_OK(smbcli_lock(cli->tree, fnum2, 0, 4, 0, READ_LOCK))) {
 260                 printf("READ lock2 succeeded! This is a locking bug\n");
 261                 correct = False;
 262         } else {
 263                 if (!check_error(__location__, cli, ERRDOS, ERRlock,
 264                                  NT_STATUS_FILE_LOCK_CONFLICT)) return False;
 265         }
 266
 267         if (NT_STATUS_IS_ERR(smbcli_lock(cli->tree, fnum1, 100, 4, 0, WRITE_LOCK))) {
 268                 printf("lock at 100 failed (%s)\n", smbcli_errstr(cli->tree));
 269         }
 270
 271         cli->session->pid = 2;
 272
 273         if (NT_STATUS_IS_OK(smbcli_unlock(cli->tree, fnum1, 100, 4))) {
 274                 printf("unlock at 100 succeeded! This is a locking bug\n");
 275                 correct = False;
 276         }
 277
 278         if (NT_STATUS_IS_OK(smbcli_unlock(cli->tree, fnum1, 0, 4))) {
 279                 printf("unlock1 succeeded! This is a locking bug\n");
 280                 correct = False;
 281         } else {
 282                 if (!check_error(__location__, cli,
 283                                  ERRDOS, ERRlock,
 284                                  NT_STATUS_RANGE_NOT_LOCKED)) return False;
 285         }
 286
 287         if (NT_STATUS_IS_OK(smbcli_unlock(cli->tree, fnum1, 0, 8))) {
 288                 printf("unlock2 succeeded! This is a locking bug\n");
 289                 correct = False;
 290         } else {
 291                 if (!check_error(__location__, cli,
 292                                  ERRDOS, ERRlock,
 293                                  NT_STATUS_RANGE_NOT_LOCKED)) return False;
 294         }
 295
 296         if (NT_STATUS_IS_OK(smbcli_lock(cli->tree, fnum3, 0, 4, 0, WRITE_LOCK))) {
 297                 printf("lock3 succeeded! This is a locking bug\n");
 298                 correct = False;
 299         } else {
 300                 if (!check_error(__location__, cli, ERRDOS, ERRlock, NT_STATUS_LOCK_NOT_GRANTED)) return False;
 301         }
 302
 303         cli->session->pid = 1;
 304
 305         if (NT_STATUS_IS_ERR(smbcli_close(cli->tree, fnum1))) {
 306                 printf("close1 failed (%s)\n", smbcli_errstr(cli->tree));
 307                 return False;
 308         }
 309
 310         if (NT_STATUS_IS_ERR(smbcli_close(cli->tree, fnum2))) {
 311                 printf("close2 failed (%s)\n", smbcli_errstr(cli->tree));
 312                 return False;
 313         }
 314
 315         if (NT_STATUS_IS_ERR(smbcli_close(cli->tree, fnum3))) {
 316                 printf("close3 failed (%s)\n", smbcli_errstr(cli->tree));
 317                 return False;
 318         }
 319
 320         if (!torture_close_connection(cli)) {
 321                 correct = False;
 322         }
 323
 324         printf("locktest2 finished\n");
 325
 326         return correct;
 327 }
 328
 329
 330 /*
 331   This test checks that
 332
 333   1) the server supports the full offset range in lock requests
 334 */
 335 BOOL torture_locktest3(void)
 336 {
 337         struct smbcli_state *cli1, *cli2;
 338         const char *fname = BASEDIR "\\lockt3.lck";
 339         int fnum1, fnum2, i;
 340         uint32_t offset;
 341         BOOL correct = True;
 342         extern int torture_numops;
 343
 344 #define NEXT_OFFSET offset += (~(uint32_t)0) / torture_numops
 345
 346         if (!torture_open_connection(&cli1) || !torture_open_connection(&cli2)) {
 347                 return False;
 348         }
 349
 350         printf("starting locktest3\n");
 351
 352         printf("Testing 32 bit offset ranges\n");
 353
 354         if (!torture_setup_dir(cli1, BASEDIR)) {
 355                 return False;
 356         }
 357
 358         fnum1 = smbcli_open(cli1->tree, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
 359         if (fnum1 == -1) {
 360                 printf("open of %s failed (%s)\n", fname, smbcli_errstr(cli1->tree));
 361                 return False;
 362         }
 363         fnum2 = smbcli_open(cli2->tree, fname, O_RDWR, DENY_NONE);
 364         if (fnum2 == -1) {
 365                 printf("open2 of %s failed (%s)\n", fname, smbcli_errstr(cli2->tree));
 366                 return False;
 367         }
 368
 369         printf("Establishing %d locks\n", torture_numops);
 370
 371         for (offset=i=0;i<torture_numops;i++) {
 372                 NEXT_OFFSET;
 373                 if (NT_STATUS_IS_ERR(smbcli_lock(cli1->tree, fnum1, offset-1, 1, 0, WRITE_LOCK))) {
 374                         printf("lock1 %d failed (%s)\n",
 375                                i,
 376                                smbcli_errstr(cli1->tree));
 377                         return False;
 378                 }
 379
 380                 if (NT_STATUS_IS_ERR(smbcli_lock(cli2->tree, fnum2, offset-2, 1, 0, WRITE_LOCK))) {
 381                         printf("lock2 %d failed (%s)\n",
 382                                i,
 383                                smbcli_errstr(cli1->tree));
 384                         return False;
 385                 }
 386         }
 387
 388         printf("Testing %d locks\n", torture_numops);
 389
 390         for (offset=i=0;i<torture_numops;i++) {
 391                 NEXT_OFFSET;
 392
 393                 if (NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, offset-2, 1, 0, WRITE_LOCK))) {
 394                         printf("error: lock1 %d succeeded!\n", i);
 395                         return False;
 396                 }
 397
 398                 if (NT_STATUS_IS_OK(smbcli_lock(cli2->tree, fnum2, offset-1, 1, 0, WRITE_LOCK))) {
 399                         printf("error: lock2 %d succeeded!\n", i);
 400                         return False;
 401                 }
 402
 403                 if (NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, offset-1, 1, 0, WRITE_LOCK))) {
 404                         printf("error: lock3 %d succeeded!\n", i);
 405                         return False;
 406                 }
 407
 408                 if (NT_STATUS_IS_OK(smbcli_lock(cli2->tree, fnum2, offset-2, 1, 0, WRITE_LOCK))) {
 409                         printf("error: lock4 %d succeeded!\n", i);
 410                         return False;
 411                 }
 412         }
 413
 414         printf("Removing %d locks\n", torture_numops);
 415
 416         for (offset=i=0;i<torture_numops;i++) {
 417                 NEXT_OFFSET;
 418
 419                 if (NT_STATUS_IS_ERR(smbcli_unlock(cli1->tree, fnum1, offset-1, 1))) {
 420                         printf("unlock1 %d failed (%s)\n",
 421                                i,
 422                                smbcli_errstr(cli1->tree));
 423                         return False;
 424                 }
 425
 426                 if (NT_STATUS_IS_ERR(smbcli_unlock(cli2->tree, fnum2, offset-2, 1))) {
 427                         printf("unlock2 %d failed (%s)\n",
 428                                i,
 429                                smbcli_errstr(cli1->tree));
 430                         return False;
 431                 }
 432         }
 433
 434         if (NT_STATUS_IS_ERR(smbcli_close(cli1->tree, fnum1))) {
 435                 printf("close1 failed (%s)\n", smbcli_errstr(cli1->tree));
 436                 return False;
 437         }
 438
 439         if (NT_STATUS_IS_ERR(smbcli_close(cli2->tree, fnum2))) {
 440                 printf("close2 failed (%s)\n", smbcli_errstr(cli2->tree));
 441                 return False;
 442         }
 443
 444         if (NT_STATUS_IS_ERR(smbcli_unlink(cli1->tree, fname))) {
 445                 printf("unlink failed (%s)\n", smbcli_errstr(cli1->tree));
 446                 return False;
 447         }
 448
 449         if (!torture_close_connection(cli1)) {
 450                 correct = False;
 451         }
 452
 453         if (!torture_close_connection(cli2)) {
 454                 correct = False;
 455         }
 456
 457         printf("finished locktest3\n");
 458
 459         return correct;
 460 }
 461
 462 #define EXPECTED(ret, v) if ((ret) != (v)) { \
 463         printf("** "); correct = False; \
 464         }
 465
 466 /*
 467   looks at overlapping locks
 468 */
 469 BOOL torture_locktest4(void)
 470 {
 471         struct smbcli_state *cli1, *cli2;
 472         const char *fname = BASEDIR "\\lockt4.lck";
 473         int fnum1, fnum2, f;
 474         BOOL ret;
 475         uint8_t buf[1000];
 476         BOOL correct = True;
 477
 478         if (!torture_open_connection(&cli1) || !torture_open_connection(&cli2)) {
 479                 return False;
 480         }
 481
 482         printf("starting locktest4\n");
 483
 484         if (!torture_setup_dir(cli1, BASEDIR)) {
 485                 return False;
 486         }
 487
 488         fnum1 = smbcli_open(cli1->tree, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
 489         fnum2 = smbcli_open(cli2->tree, fname, O_RDWR, DENY_NONE);
 490
 491         memset(buf, 0, sizeof(buf));
 492
 493         if (smbcli_write(cli1->tree, fnum1, 0, buf, 0, sizeof(buf)) != sizeof(buf)) {
 494                 printf("Failed to create file\n");
 495                 correct = False;
 496                 goto fail;
 497         }
 498
 499         ret = NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, 0, 4, 0, WRITE_LOCK)) &&
 500               NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, 2, 4, 0, WRITE_LOCK));
 501         EXPECTED(ret, False);
 502         printf("the same process %s set overlapping write locks\n", ret?"can":"cannot");
 503
 504         ret = NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, 10, 4, 0, READ_LOCK)) &&
 505               NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, 12, 4, 0, READ_LOCK));
 506         EXPECTED(ret, True);
 507         printf("the same process %s set overlapping read locks\n", ret?"can":"cannot");
 508
 509         ret = NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, 20, 4, 0, WRITE_LOCK)) &&
 510               NT_STATUS_IS_OK(smbcli_lock(cli2->tree, fnum2, 22, 4, 0, WRITE_LOCK));
 511         EXPECTED(ret, False);
 512         printf("a different connection %s set overlapping write locks\n", ret?"can":"cannot");
 513
 514         ret = NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, 30, 4, 0, READ_LOCK)) &&
 515                 NT_STATUS_IS_OK(smbcli_lock(cli2->tree, fnum2, 32, 4, 0, READ_LOCK));
 516         EXPECTED(ret, True);
 517         printf("a different connection %s set overlapping read locks\n", ret?"can":"cannot");
 518
 519         ret = NT_STATUS_IS_OK((cli1->session->pid = 1, smbcli_lock(cli1->tree, fnum1, 40, 4, 0, WRITE_LOCK))) &&
 520               NT_STATUS_IS_OK((cli1->session->pid = 2, smbcli_lock(cli1->tree, fnum1, 42, 4, 0, WRITE_LOCK)));
 521         EXPECTED(ret, False);
 522         printf("a different pid %s set overlapping write locks\n", ret?"can":"cannot");
 523
 524         ret = NT_STATUS_IS_OK((cli1->session->pid = 1, smbcli_lock(cli1->tree, fnum1, 50, 4, 0, READ_LOCK))) &&
 525               NT_STATUS_IS_OK((cli1->session->pid = 2, smbcli_lock(cli1->tree, fnum1, 52, 4, 0, READ_LOCK)));
 526         EXPECTED(ret, True);
 527         printf("a different pid %s set overlapping read locks\n", ret?"can":"cannot");
 528
 529         ret = NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, 60, 4, 0, READ_LOCK)) &&
 530               NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, 60, 4, 0, READ_LOCK));
 531         EXPECTED(ret, True);
 532         printf("the same process %s set the same read lock twice\n", ret?"can":"cannot");
 533
 534         ret = NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, 70, 4, 0, WRITE_LOCK)) &&
 535               NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, 70, 4, 0, WRITE_LOCK));
 536         EXPECTED(ret, False);
 537         printf("the same process %s set the same write lock twice\n", ret?"can":"cannot");
 538
 539         ret = NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, 80, 4, 0, READ_LOCK)) &&
 540               NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, 80, 4, 0, WRITE_LOCK));
 541         EXPECTED(ret, False);
 542         printf("the same process %s overlay a read lock with a write lock\n", ret?"can":"cannot");
 543
 544         ret = NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, 90, 4, 0, WRITE_LOCK)) &&
 545               NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, 90, 4, 0, READ_LOCK));
 546         EXPECTED(ret, True);
 547         printf("the same process %s overlay a write lock with a read lock\n", ret?"can":"cannot");
 548
 549         ret = NT_STATUS_IS_OK((cli1->session->pid = 1, smbcli_lock(cli1->tree, fnum1, 100, 4, 0, WRITE_LOCK))) &&
 550               NT_STATUS_IS_OK((cli1->session->pid = 2, smbcli_lock(cli1->tree, fnum1, 100, 4, 0, READ_LOCK)));
 551         EXPECTED(ret, False);
 552         printf("a different pid %s overlay a write lock with a read lock\n", ret?"can":"cannot");
 553
 554         ret = NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, 110, 4, 0, READ_LOCK)) &&
 555               NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, 112, 4, 0, READ_LOCK)) &&
 556               NT_STATUS_IS_OK(smbcli_unlock(cli1->tree, fnum1, 110, 6));
 557         EXPECTED(ret, False);
 558         printf("the same process %s coalesce read locks\n", ret?"can":"cannot");
 559
 560
 561         ret = NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, 120, 4, 0, WRITE_LOCK)) &&
 562               (smbcli_read(cli2->tree, fnum2, buf, 120, 4) == 4);
 563         EXPECTED(ret, False);
 564         printf("this server %s strict write locking\n", ret?"doesn't do":"does");
 565
 566         ret = NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, 130, 4, 0, READ_LOCK)) &&
 567               (smbcli_write(cli2->tree, fnum2, 0, buf, 130, 4) == 4);
 568         EXPECTED(ret, False);
 569         printf("this server %s strict read locking\n", ret?"doesn't do":"does");
 570
 571
 572         ret = NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, 140, 4, 0, READ_LOCK)) &&
 573               NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, 140, 4, 0, READ_LOCK)) &&
 574               NT_STATUS_IS_OK(smbcli_unlock(cli1->tree, fnum1, 140, 4)) &&
 575               NT_STATUS_IS_OK(smbcli_unlock(cli1->tree, fnum1, 140, 4));
 576         EXPECTED(ret, True);
 577         printf("this server %s do recursive read locking\n", ret?"does":"doesn't");
 578
 579
 580         ret = NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, 150, 4, 0, WRITE_LOCK)) &&
 581               NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, 150, 4, 0, READ_LOCK)) &&
 582               NT_STATUS_IS_OK(smbcli_unlock(cli1->tree, fnum1, 150, 4)) &&
 583               (smbcli_read(cli2->tree, fnum2, buf, 150, 4) == 4) &&
 584               !(smbcli_write(cli2->tree, fnum2, 0, buf, 150, 4) == 4) &&
 585               NT_STATUS_IS_OK(smbcli_unlock(cli1->tree, fnum1, 150, 4));
 586         EXPECTED(ret, True);
 587         printf("this server %s do recursive lock overlays\n", ret?"does":"doesn't");
 588
 589         ret = NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, 160, 4, 0, READ_LOCK)) &&
 590               NT_STATUS_IS_OK(smbcli_unlock(cli1->tree, fnum1, 160, 4)) &&
 591               (smbcli_write(cli2->tree, fnum2, 0, buf, 160, 4) == 4) &&
 592               (smbcli_read(cli2->tree, fnum2, buf, 160, 4) == 4);
 593         EXPECTED(ret, True);
 594         printf("the same process %s remove a read lock using write locking\n", ret?"can":"cannot");
 595
 596         ret = NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, 170, 4, 0, WRITE_LOCK)) &&
 597               NT_STATUS_IS_OK(smbcli_unlock(cli1->tree, fnum1, 170, 4)) &&
 598               (smbcli_write(cli2->tree, fnum2, 0, buf, 170, 4) == 4) &&
 599               (smbcli_read(cli2->tree, fnum2, buf, 170, 4) == 4);
 600         EXPECTED(ret, True);
 601         printf("the same process %s remove a write lock using read locking\n", ret?"can":"cannot");
 602
 603         ret = NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, 190, 4, 0, WRITE_LOCK)) &&
 604               NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, 190, 4, 0, READ_LOCK)) &&
 605               NT_STATUS_IS_OK(smbcli_unlock(cli1->tree, fnum1, 190, 4)) &&
 606               !(smbcli_write(cli2->tree, fnum2, 0, buf, 190, 4) == 4) &&
 607               (smbcli_read(cli2->tree, fnum2, buf, 190, 4) == 4);
 608         EXPECTED(ret, True);
 609         printf("the same process %s remove the first lock first\n", ret?"does":"doesn't");
 610
 611         smbcli_close(cli1->tree, fnum1);
 612         smbcli_close(cli2->tree, fnum2);
 613         fnum1 = smbcli_open(cli1->tree, fname, O_RDWR, DENY_NONE);
 614         f = smbcli_open(cli1->tree, fname, O_RDWR, DENY_NONE);
 615         ret = NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, 0, 8, 0, READ_LOCK)) &&
 616               NT_STATUS_IS_OK(smbcli_lock(cli1->tree, f, 0, 1, 0, READ_LOCK)) &&
 617               NT_STATUS_IS_OK(smbcli_close(cli1->tree, fnum1)) &&
 618               ((fnum1 = smbcli_open(cli1->tree, fname, O_RDWR, DENY_NONE)) != -1) &&
 619               NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, 7, 1, 0, WRITE_LOCK));
 620         smbcli_close(cli1->tree, f);
 621         smbcli_close(cli1->tree, fnum1);
 622         EXPECTED(ret, True);
 623         printf("the server %s have the NT byte range lock bug\n", !ret?"does":"doesn't");
 624
 625  fail:
 626         smbcli_close(cli1->tree, fnum1);
 627         smbcli_close(cli2->tree, fnum2);
 628         smbcli_unlink(cli1->tree, fname);
 629         torture_close_connection(cli1);
 630         torture_close_connection(cli2);
 631
 632         printf("finished locktest4\n");
 633         return correct;
 634 }
 635
 636 /*
 637   looks at lock upgrade/downgrade.
 638 */
 639 BOOL torture_locktest5(void)
 640 {
 641         struct smbcli_state *cli1, *cli2;
 642         const char *fname = BASEDIR "\\lockt5.lck";
 643         int fnum1, fnum2, fnum3;
 644         BOOL ret;
 645         uint8_t buf[1000];
 646         BOOL correct = True;
 647
 648         if (!torture_open_connection(&cli1) || !torture_open_connection(&cli2)) {
 649                 return False;
 650         }
 651
 652         printf("starting locktest5\n");
 653
 654         if (!torture_setup_dir(cli1, BASEDIR)) {
 655                 return False;
 656         }
 657
 658         fnum1 = smbcli_open(cli1->tree, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
 659         fnum2 = smbcli_open(cli2->tree, fname, O_RDWR, DENY_NONE);
 660         fnum3 = smbcli_open(cli1->tree, fname, O_RDWR, DENY_NONE);
 661
 662         memset(buf, 0, sizeof(buf));
 663
 664         if (smbcli_write(cli1->tree, fnum1, 0, buf, 0, sizeof(buf)) != sizeof(buf)) {
 665                 printf("Failed to create file\n");
 666                 correct = False;
 667                 goto fail;
 668         }
 669
 670         /* Check for NT bug... */
 671         ret = NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, 0, 8, 0, READ_LOCK)) &&
 672                   NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum3, 0, 1, 0, READ_LOCK));
 673         smbcli_close(cli1->tree, fnum1);
 674         fnum1 = smbcli_open(cli1->tree, fname, O_RDWR, DENY_NONE);
 675         ret = NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, 7, 1, 0, WRITE_LOCK));
 676         EXPECTED(ret, True);
 677         printf("this server %s the NT locking bug\n", ret ? "doesn't have" : "has");
 678         smbcli_close(cli1->tree, fnum1);
 679         fnum1 = smbcli_open(cli1->tree, fname, O_RDWR, DENY_NONE);
 680         smbcli_unlock(cli1->tree, fnum3, 0, 1);
 681
 682         ret = NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, 0, 4, 0, WRITE_LOCK)) &&
 683               NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, 1, 1, 0, READ_LOCK));
 684         EXPECTED(ret, True);
 685         printf("the same process %s overlay a write with a read lock\n", ret?"can":"cannot");
 686
 687         ret = NT_STATUS_IS_OK(smbcli_lock(cli2->tree, fnum2, 0, 4, 0, READ_LOCK));
 688         EXPECTED(ret, False);
 689
 690         printf("a different processs %s get a read lock on the first process lock stack\n", ret?"can":"cannot");
 691
 692         /* Unlock the process 2 lock. */
 693         smbcli_unlock(cli2->tree, fnum2, 0, 4);
 694
 695         ret = NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum3, 0, 4, 0, READ_LOCK));
 696         EXPECTED(ret, False);
 697
 698         printf("the same processs on a different fnum %s get a read lock\n", ret?"can":"cannot");
 699
 700         /* Unlock the process 1 fnum3 lock. */
 701         smbcli_unlock(cli1->tree, fnum3, 0, 4);
 702
 703         /* Stack 2 more locks here. */
 704         ret = NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, 0, 4, 0, READ_LOCK)) &&
 705                   NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, 0, 4, 0, READ_LOCK));
 706
 707         EXPECTED(ret, True);
 708         printf("the same process %s stack read locks\n", ret?"can":"cannot");
 709
 710         /* Unlock the first process lock, then check this was the WRITE lock that was
 711                 removed. */
 712
 713 ret = NT_STATUS_IS_OK(smbcli_unlock(cli1->tree, fnum1, 0, 4)) &&
 714         NT_STATUS_IS_OK(smbcli_lock(cli2->tree, fnum2, 0, 4, 0, READ_LOCK));
 715
 716         EXPECTED(ret, True);
 717         printf("the first unlock removes the %s lock\n", ret?"WRITE":"READ");
 718
 719         /* Unlock the process 2 lock. */
 720         smbcli_unlock(cli2->tree, fnum2, 0, 4);
 721
 722         /* We should have 3 stacked locks here. Ensure we need to do 3 unlocks. */
 723
 724         ret = NT_STATUS_IS_OK(smbcli_unlock(cli1->tree, fnum1, 1, 1)) &&
 725                   NT_STATUS_IS_OK(smbcli_unlock(cli1->tree, fnum1, 0, 4)) &&
 726                   NT_STATUS_IS_OK(smbcli_unlock(cli1->tree, fnum1, 0, 4));
 727
 728         EXPECTED(ret, True);
 729         printf("the same process %s unlock the stack of 4 locks\n", ret?"can":"cannot");
 730
 731         /* Ensure the next unlock fails. */
 732         ret = NT_STATUS_IS_OK(smbcli_unlock(cli1->tree, fnum1, 0, 4));
 733         EXPECTED(ret, False);
 734         printf("the same process %s count the lock stack\n", !ret?"can":"cannot");
 735
 736         /* Ensure connection 2 can get a write lock. */
 737         ret = NT_STATUS_IS_OK(smbcli_lock(cli2->tree, fnum2, 0, 4, 0, WRITE_LOCK));
 738         EXPECTED(ret, True);
 739
 740         printf("a different processs %s get a write lock on the unlocked stack\n", ret?"can":"cannot");
 741
 742
 743  fail:
 744         smbcli_close(cli1->tree, fnum1);
 745         smbcli_close(cli2->tree, fnum2);
 746         smbcli_unlink(cli1->tree, fname);
 747         if (!torture_close_connection(cli1)) {
 748                 correct = False;
 749         }
 750         if (!torture_close_connection(cli2)) {
 751                 correct = False;
 752         }
 753
 754         printf("finished locktest5\n");
 755
 756         return correct;
 757 }
 758
 759 /*
 760   tries the unusual lockingX locktype bits
 761 */
 762 BOOL torture_locktest6(void)
 763 {
 764         struct smbcli_state *cli;
 765         const char *fname[1] = { "\\lock6.txt" };
 766         int i;
 767         int fnum;
 768         NTSTATUS status;
 769
 770         if (!torture_open_connection(&cli)) {
 771                 return False;
 772         }
 773
 774         if (!torture_setup_dir(cli, BASEDIR)) {
 775                 return False;
 776         }
 777
 778         printf("starting locktest6\n");
 779
 780         for (i=0;i<1;i++) {
 781                 printf("Testing %s\n", fname[i]);
 782
 783                 smbcli_unlink(cli->tree, fname[i]);
 784
 785                 fnum = smbcli_open(cli->tree, fname[i], O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
 786                 status = smbcli_locktype(cli->tree, fnum, 0, 8, 0, LOCKING_ANDX_CHANGE_LOCKTYPE);
 787                 smbcli_close(cli->tree, fnum);
 788                 printf("CHANGE_LOCKTYPE gave %s\n", nt_errstr(status));
 789
 790                 fnum = smbcli_open(cli->tree, fname[i], O_RDWR, DENY_NONE);
 791                 status = smbcli_locktype(cli->tree, fnum, 0, 8, 0, LOCKING_ANDX_CANCEL_LOCK);
 792                 smbcli_close(cli->tree, fnum);
 793                 printf("CANCEL_LOCK gave %s\n", nt_errstr(status));
 794
 795                 smbcli_unlink(cli->tree, fname[i]);
 796         }
 797
 798         torture_close_connection(cli);
 799
 800         printf("finished locktest6\n");
 801         return True;
 802 }
 803
 804 BOOL torture_locktest7(void)
 805 {
 806         struct smbcli_state *cli1;
 807         const char *fname = BASEDIR "\\lockt7.lck";
 808         int fnum1;
 809         int fnum2 = -1;
 810         size_t size;
 811         uint8_t buf[200];
 812         BOOL correct = False;
 813
 814         if (!torture_open_connection(&cli1)) {
 815                 return False;
 816         }
 817
 818         printf("starting locktest7\n");
 819
 820         if (!torture_setup_dir(cli1, BASEDIR)) {
 821                 return False;
 822         }
 823
 824         fnum1 = smbcli_open(cli1->tree, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
 825
 826         memset(buf, 0, sizeof(buf));
 827
 828         if (smbcli_write(cli1->tree, fnum1, 0, buf, 0, sizeof(buf)) != sizeof(buf)) {
 829                 printf("Failed to create file (%s)\n", __location__);
 830                 goto fail;
 831         }
 832
 833         cli1->session->pid = 1;
 834
 835         if (NT_STATUS_IS_ERR(smbcli_lock(cli1->tree, fnum1, 130, 4, 0, READ_LOCK))) {
 836                 printf("Unable to apply read lock on range 130:4, error was %s (%s)\n",
 837                        smbcli_errstr(cli1->tree), __location__);
 838                 goto fail;
 839         } else {
 840                 printf("pid1 successfully locked range 130:4 for READ\n");
 841         }
 842
 843         if (smbcli_read(cli1->tree, fnum1, buf, 130, 4) != 4) {
 844                 printf("pid1 unable to read the range 130:4, error was %s (%s)\n",
 845                        smbcli_errstr(cli1->tree), __location__);
 846                 goto fail;
 847         } else {
 848                 printf("pid1 successfully read the range 130:4\n");
 849         }
 850
 851         if (smbcli_write(cli1->tree, fnum1, 0, buf, 130, 4) != 4) {
 852                 printf("pid1 unable to write to the range 130:4, error was %s\n", smbcli_errstr(cli1->tree));
 853                 if (NT_STATUS_V(smbcli_nt_error(cli1->tree)) != NT_STATUS_V(NT_STATUS_FILE_LOCK_CONFLICT)) {
 854                         printf("Incorrect error (should be NT_STATUS_FILE_LOCK_CONFLICT) (%s)\n",
 855                                __location__);
 856                         goto fail;
 857                 }
 858         } else {
 859                 printf("pid1 successfully wrote to the range 130:4 (should be denied) (%s)\n",
 860                        __location__);
 861                 goto fail;
 862         }
 863
 864         cli1->session->pid = 2;
 865
 866         if (smbcli_read(cli1->tree, fnum1, buf, 130, 4) != 4) {
 867                 printf("pid2 unable to read the range 130:4, error was %s\n", smbcli_errstr(cli1->tree));
 868         } else {
 869                 printf("pid2 successfully read the range 130:4\n");
 870         }
 871
 872         if (smbcli_write(cli1->tree, fnum1, 0, buf, 130, 4) != 4) {
 873                 printf("pid2 unable to write to the range 130:4, error was %s\n", smbcli_errstr(cli1->tree));
 874                 if (NT_STATUS_V(smbcli_nt_error(cli1->tree)) != NT_STATUS_V(NT_STATUS_FILE_LOCK_CONFLICT)) {
 875                         printf("Incorrect error (should be NT_STATUS_FILE_LOCK_CONFLICT) (%s)\n",
 876                                __location__);
 877                         goto fail;
 878                 }
 879         } else {
 880                 printf("pid2 successfully wrote to the range 130:4 (should be denied) (%s)\n",
 881                        __location__);
 882                 goto fail;
 883         }
 884
 885         cli1->session->pid = 1;
 886         smbcli_unlock(cli1->tree, fnum1, 130, 4);
 887
 888         if (NT_STATUS_IS_ERR(smbcli_lock(cli1->tree, fnum1, 130, 4, 0, WRITE_LOCK))) {
 889                 printf("Unable to apply write lock on range 130:4, error was %s (%s)\n",
 890                        smbcli_errstr(cli1->tree), __location__);
 891                 goto fail;
 892         } else {
 893                 printf("pid1 successfully locked range 130:4 for WRITE\n");
 894         }
 895
 896         if (smbcli_read(cli1->tree, fnum1, buf, 130, 4) != 4) {
 897                 printf("pid1 unable to read the range 130:4, error was %s (%s)\n",
 898                        smbcli_errstr(cli1->tree), __location__);
 899                 goto fail;
 900         } else {
 901                 printf("pid1 successfully read the range 130:4\n");
 902         }
 903
 904         if (smbcli_write(cli1->tree, fnum1, 0, buf, 130, 4) != 4) {
 905                 printf("pid1 unable to write to the range 130:4, error was %s (%s)\n",
 906                        smbcli_errstr(cli1->tree), __location__);
 907                 goto fail;
 908         } else {
 909                 printf("pid1 successfully wrote to the range 130:4\n");
 910         }
 911
 912         cli1->session->pid = 2;
 913
 914         if (smbcli_read(cli1->tree, fnum1, buf, 130, 4) != 4) {
 915                 printf("pid2 unable to read the range 130:4, error was %s\n",
 916                        smbcli_errstr(cli1->tree));
 917                 if (NT_STATUS_V(smbcli_nt_error(cli1->tree)) != NT_STATUS_V(NT_STATUS_FILE_LOCK_CONFLICT)) {
 918                         printf("Incorrect error (should be NT_STATUS_FILE_LOCK_CONFLICT) (%s)\n",
 919                                __location__);
 920                         goto fail;
 921                 }
 922         } else {
 923                 printf("pid2 successfully read the range 130:4 (should be denied) (%s)\n",
 924                        __location__);
 925                 goto fail;
 926         }
 927
 928         if (smbcli_write(cli1->tree, fnum1, 0, buf, 130, 4) != 4) {
 929                 printf("pid2 unable to write to the range 130:4, error was %s\n",
 930                        smbcli_errstr(cli1->tree));
 931                 if (NT_STATUS_V(smbcli_nt_error(cli1->tree)) != NT_STATUS_V(NT_STATUS_FILE_LOCK_CONFLICT)) {
 932                         printf("Incorrect error (should be NT_STATUS_FILE_LOCK_CONFLICT) (%s)\n",
 933                                __location__);
 934                         goto fail;
 935                 }
 936         } else {
 937                 printf("pid2 successfully wrote to the range 130:4 (should be denied) (%s)\n",
 938                        __location__);
 939                 goto fail;
 940         }
 941
 942         printf("Testing truncate of locked file.\n");
 943
 944         fnum2 = smbcli_open(cli1->tree, fname, O_RDWR|O_TRUNC, DENY_NONE);
 945
 946         if (fnum2 == -1) {
 947                 printf("Unable to truncate locked file (%s)\n", __location__);
 948                 correct = False;
 949                 goto fail;
 950         } else {
 951                 printf("Truncated locked file.\n");
 952         }
 953
 954         if (NT_STATUS_IS_ERR(smbcli_getatr(cli1->tree, fname, NULL, &size, NULL))) {
 955                 printf("getatr failed (%s) (%s)\n", smbcli_errstr(cli1->tree), __location__);
 956                 correct = False;
 957                 goto fail;
 958         }
 959
 960         if (size != 0) {
 961                 printf("Unable to truncate locked file. Size was %u (%s)\n", size, __location__);
 962                 correct = False;
 963                 goto fail;
 964         }
 965
 966         cli1->session->pid = 1;
 967
 968         smbcli_unlock(cli1->tree, fnum1, 130, 4);
 969         correct = True;
 970
 971 fail:
 972         smbcli_close(cli1->tree, fnum1);
 973         smbcli_close(cli1->tree, fnum2);
 974         smbcli_unlink(cli1->tree, fname);
 975         torture_close_connection(cli1);
 976
 977         printf("finished locktest7\n");
 978         return correct;
 979 }
 980