source3/torture/torture.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    SMB torture tester
   4    Copyright (C) Andrew Tridgell 1997-1998
   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 2 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, write to the Free Software
  18    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19 */
  20
  21 #include "includes.h"
  22
  23 extern char *optarg;
  24 extern int optind;
  25
  26 static fstring host, workgroup, share, password, username, myname;
  27 static int max_protocol = PROTOCOL_NT1;
  28 static const char *sockops="TCP_NODELAY";
  29 static int nprocs=1;
  30 static int port_to_use=0;
  31 int torture_numops=100;
  32 static int procnum; /* records process count number when forking */
  33 static struct cli_state *current_cli;
  34 static fstring randomfname;
  35 static BOOL use_oplocks;
  36 static BOOL use_level_II_oplocks;
  37 static const char *client_txt = "client_oplocks.txt";
  38 static BOOL use_kerberos;
  39 static fstring multishare_conn_fname;
  40 static BOOL use_multishare_conn = False;
  41
  42 BOOL torture_showall = False;
  43
  44 static double create_procs(BOOL (*fn)(int), BOOL *result);
  45
  46
  47 static struct timeval tp1,tp2;
  48
  49
  50 void start_timer(void)
  51 {
  52         GetTimeOfDay(&tp1);
  53 }
  54
  55 double end_timer(void)
  56 {
  57         GetTimeOfDay(&tp2);
  58         return((tp2.tv_sec - tp1.tv_sec) +
  59                (tp2.tv_usec - tp1.tv_usec)*1.0e-6);
  60 }
  61
  62
  63 /* return a pointer to a anonymous shared memory segment of size "size"
  64    which will persist across fork() but will disappear when all processes
  65    exit
  66
  67    The memory is not zeroed
  68
  69    This function uses system5 shared memory. It takes advantage of a property
  70    that the memory is not destroyed if it is attached when the id is removed
  71    */
  72 void *shm_setup(int size)
  73 {
  74         int shmid;
  75         void *ret;
  76
  77         shmid = shmget(IPC_PRIVATE, size, S_IRUSR | S_IWUSR);
  78         if (shmid == -1) {
  79                 printf("can't get shared memory\n");
  80                 exit(1);
  81         }
  82         ret = (void *)shmat(shmid, 0, 0);
  83         if (!ret || ret == (void *)-1) {
  84                 printf("can't attach to shared memory\n");
  85                 return NULL;
  86         }
  87         /* the following releases the ipc, but note that this process
  88            and all its children will still have access to the memory, its
  89            just that the shmid is no longer valid for other shm calls. This
  90            means we don't leave behind lots of shm segments after we exit
  91
  92            See Stevens "advanced programming in unix env" for details
  93            */
  94         shmctl(shmid, IPC_RMID, 0);
  95
  96         return ret;
  97 }
  98
  99
 100 static struct cli_state *open_nbt_connection(void)
 101 {
 102         struct nmb_name called, calling;
 103         struct in_addr ip;
 104         struct cli_state *c;
 105
 106         make_nmb_name(&calling, myname, 0x0);
 107         make_nmb_name(&called , host, 0x20);
 108
 109         zero_ip(&ip);
 110
 111         if (!(c = cli_initialise())) {
 112                 printf("Failed initialize cli_struct to connect with %s\n", host);
 113                 return NULL;
 114         }
 115
 116         c->port = port_to_use;
 117
 118         if (!cli_connect(c, host, &ip)) {
 119                 printf("Failed to connect with %s\n", host);
 120                 return NULL;
 121         }
 122
 123         c->use_kerberos = use_kerberos;
 124
 125         c->timeout = 120000; /* set a really long timeout (2 minutes) */
 126         if (use_oplocks) c->use_oplocks = True;
 127         if (use_level_II_oplocks) c->use_level_II_oplocks = True;
 128
 129         if (!cli_session_request(c, &calling, &called)) {
 130                 /*
 131                  * Well, that failed, try *SMBSERVER ...
 132                  * However, we must reconnect as well ...
 133                  */
 134                 if (!cli_connect(c, host, &ip)) {
 135                         printf("Failed to connect with %s\n", host);
 136                         return NULL;
 137                 }
 138
 139                 make_nmb_name(&called, "*SMBSERVER", 0x20);
 140                 if (!cli_session_request(c, &calling, &called)) {
 141                         printf("%s rejected the session\n",host);
 142                         printf("We tried with a called name of %s & %s\n",
 143                                 host, "*SMBSERVER");
 144                         cli_shutdown(c);
 145                         return NULL;
 146                 }
 147         }
 148
 149         return c;
 150 }
 151
 152 /* Insert a NULL at the first separator of the given path and return a pointer
 153  * to the remainder of the string.
 154  */
 155 static char *
 156 terminate_path_at_separator(char * path)
 157 {
 158         char * p;
 159
 160         if (!path) {
 161                 return NULL;
 162         }
 163
 164         if ((p = strchr_m(path, '/'))) {
 165                 *p = '\0';
 166                 return p + 1;
 167         }
 168
 169         if ((p = strchr_m(path, '\\'))) {
 170                 *p = '\0';
 171                 return p + 1;
 172         }
 173
 174         /* No separator. */
 175         return NULL;
 176 }
 177
 178 /*
 179   parse a //server/share type UNC name
 180 */
 181 BOOL smbcli_parse_unc(const char *unc_name, TALLOC_CTX *mem_ctx,
 182                       char **hostname, char **sharename)
 183 {
 184         char *p;
 185
 186         *hostname = *sharename = NULL;
 187
 188         if (strncmp(unc_name, "\\\\", 2) &&
 189             strncmp(unc_name, "//", 2)) {
 190                 return False;
 191         }
 192
 193         *hostname = talloc_strdup(mem_ctx, &unc_name[2]);
 194         p = terminate_path_at_separator(*hostname);
 195
 196         if (p && *p) {
 197                 *sharename = talloc_strdup(mem_ctx, p);
 198                 terminate_path_at_separator(*sharename);
 199         }
 200
 201         if (*hostname && *sharename) {
 202                 return True;
 203         }
 204
 205         TALLOC_FREE(*hostname);
 206         TALLOC_FREE(*sharename);
 207         return False;
 208 }
 209
 210 static BOOL torture_open_connection_share(struct cli_state **c,
 211                                    const char *hostname,
 212                                    const char *sharename)
 213 {
 214         BOOL retry;
 215         int flags = 0;
 216         NTSTATUS status;
 217
 218         if (use_kerberos)
 219                 flags |= CLI_FULL_CONNECTION_USE_KERBEROS;
 220
 221         status = cli_full_connection(c, myname,
 222                                      hostname, NULL, port_to_use,
 223                                      sharename, "?????",
 224                                      username, workgroup,
 225                                      password, flags, Undefined, &retry);
 226         if (!NT_STATUS_IS_OK(status)) {
 227                 printf("failed to open share connection: //%s/%s port:%d - %s\n",
 228                         hostname, sharename, port_to_use, nt_errstr(status));
 229                 return False;
 230         }
 231
 232         if (use_oplocks) (*c)->use_oplocks = True;
 233         if (use_level_II_oplocks) (*c)->use_level_II_oplocks = True;
 234         (*c)->timeout = 120000; /* set a really long timeout (2 minutes) */
 235
 236         return True;
 237 }
 238
 239 void torture_open_connection_free_unclist(char **unc_list)
 240 {
 241         if (unc_list!=NULL)
 242         {
 243                 SAFE_FREE(unc_list[0]);
 244                 SAFE_FREE(unc_list);
 245         }
 246 }
 247
 248 BOOL torture_open_connection(struct cli_state **c, int conn_index)
 249 {
 250         char **unc_list = NULL;
 251         int num_unc_names = 0;
 252         BOOL result;
 253
 254         if (use_multishare_conn==True) {
 255                 char *h, *s;
 256                 unc_list = file_lines_load(multishare_conn_fname, &num_unc_names, 0);
 257                 if (!unc_list || num_unc_names <= 0) {
 258                         printf("Failed to load unc names list from '%s'\n", multishare_conn_fname);
 259                         exit(1);
 260                 }
 261
 262                 if (!smbcli_parse_unc(unc_list[conn_index % num_unc_names],
 263                                       NULL, &h, &s)) {
 264                         printf("Failed to parse UNC name %s\n",
 265                                unc_list[conn_index % num_unc_names]);
 266                         torture_open_connection_free_unclist(unc_list);
 267                         exit(1);
 268                 }
 269
 270                 result = torture_open_connection_share(c, h, s);
 271
 272                 /* h, s were copied earlier */
 273                 torture_open_connection_free_unclist(unc_list);
 274                 return result;
 275         }
 276
 277         return torture_open_connection_share(c, host, share);
 278 }
 279
 280 BOOL torture_cli_session_setup2(struct cli_state *cli, uint16 *new_vuid)
 281 {
 282         uint16 old_vuid = cli->vuid;
 283         fstring old_user_name;
 284         size_t passlen = strlen(password);
 285         BOOL ret;
 286
 287         fstrcpy(old_user_name, cli->user_name);
 288         cli->vuid = 0;
 289         ret = NT_STATUS_IS_OK(cli_session_setup(cli, username,
 290                                                 password, passlen,
 291                                                 password, passlen,
 292                                                 workgroup));
 293         *new_vuid = cli->vuid;
 294         cli->vuid = old_vuid;
 295         fstrcpy(cli->user_name, old_user_name);
 296         return ret;
 297 }
 298
 299
 300 BOOL torture_close_connection(struct cli_state *c)
 301 {
 302         BOOL ret = True;
 303         if (!cli_tdis(c)) {
 304                 printf("tdis failed (%s)\n", cli_errstr(c));
 305                 ret = False;
 306         }
 307
 308         cli_shutdown(c);
 309
 310         return ret;
 311 }
 312
 313
 314 /* check if the server produced the expected error code */
 315 static BOOL check_error(int line, struct cli_state *c,
 316                         uint8 eclass, uint32 ecode, NTSTATUS nterr)
 317 {
 318         if (cli_is_dos_error(c)) {
 319                 uint8 cclass;
 320                 uint32 num;
 321
 322                 /* Check DOS error */
 323
 324                 cli_dos_error(c, &cclass, &num);
 325
 326                 if (eclass != cclass || ecode != num) {
 327                         printf("unexpected error code class=%d code=%d\n",
 328                                (int)cclass, (int)num);
 329                         printf(" expected %d/%d %s (line=%d)\n",
 330                                (int)eclass, (int)ecode, nt_errstr(nterr), line);
 331                         return False;
 332                 }
 333
 334         } else {
 335                 NTSTATUS status;
 336
 337                 /* Check NT error */
 338
 339                 status = cli_nt_error(c);
 340
 341                 if (NT_STATUS_V(nterr) != NT_STATUS_V(status)) {
 342                         printf("unexpected error code %s\n", nt_errstr(status));
 343                         printf(" expected %s (line=%d)\n", nt_errstr(nterr), line);
 344                         return False;
 345                 }
 346         }
 347
 348         return True;
 349 }
 350
 351
 352 static BOOL wait_lock(struct cli_state *c, int fnum, uint32 offset, uint32 len)
 353 {
 354         while (!cli_lock(c, fnum, offset, len, -1, WRITE_LOCK)) {
 355                 if (!check_error(__LINE__, c, ERRDOS, ERRlock, NT_STATUS_LOCK_NOT_GRANTED)) return False;
 356         }
 357         return True;
 358 }
 359
 360
 361 static BOOL rw_torture(struct cli_state *c)
 362 {
 363         const char *lockfname = "\\torture.lck";
 364         fstring fname;
 365         int fnum;
 366         int fnum2;
 367         pid_t pid2, pid = getpid();
 368         int i, j;
 369         char buf[1024];
 370         BOOL correct = True;
 371
 372         memset(buf, '\0', sizeof(buf));
 373
 374         fnum2 = cli_open(c, lockfname, O_RDWR | O_CREAT | O_EXCL,
 375                          DENY_NONE);
 376         if (fnum2 == -1)
 377                 fnum2 = cli_open(c, lockfname, O_RDWR, DENY_NONE);
 378         if (fnum2 == -1) {
 379                 printf("open of %s failed (%s)\n", lockfname, cli_errstr(c));
 380                 return False;
 381         }
 382
 383
 384         for (i=0;i<torture_numops;i++) {
 385                 unsigned n = (unsigned)sys_random()%10;
 386                 if (i % 10 == 0) {
 387                         printf("%d\r", i); fflush(stdout);
 388                 }
 389                 slprintf(fname, sizeof(fstring) - 1, "\\torture.%u", n);
 390
 391                 if (!wait_lock(c, fnum2, n*sizeof(int), sizeof(int))) {
 392                         return False;
 393                 }
 394
 395                 fnum = cli_open(c, fname, O_RDWR | O_CREAT | O_TRUNC, DENY_ALL);
 396                 if (fnum == -1) {
 397                         printf("open failed (%s)\n", cli_errstr(c));
 398                         correct = False;
 399                         break;
 400                 }
 401
 402                 if (cli_write(c, fnum, 0, (char *)&pid, 0, sizeof(pid)) != sizeof(pid)) {
 403                         printf("write failed (%s)\n", cli_errstr(c));
 404                         correct = False;
 405                 }
 406
 407                 for (j=0;j<50;j++) {
 408                         if (cli_write(c, fnum, 0, (char *)buf,
 409                                       sizeof(pid)+(j*sizeof(buf)),
 410                                       sizeof(buf)) != sizeof(buf)) {
 411                                 printf("write failed (%s)\n", cli_errstr(c));
 412                                 correct = False;
 413                         }
 414                 }
 415
 416                 pid2 = 0;
 417
 418                 if (cli_read(c, fnum, (char *)&pid2, 0, sizeof(pid)) != sizeof(pid)) {
 419                         printf("read failed (%s)\n", cli_errstr(c));
 420                         correct = False;
 421                 }
 422
 423                 if (pid2 != pid) {
 424                         printf("data corruption!\n");
 425                         correct = False;
 426                 }
 427
 428                 if (!cli_close(c, fnum)) {
 429                         printf("close failed (%s)\n", cli_errstr(c));
 430                         correct = False;
 431                 }
 432
 433                 if (!cli_unlink(c, fname)) {
 434                         printf("unlink failed (%s)\n", cli_errstr(c));
 435                         correct = False;
 436                 }
 437
 438                 if (!cli_unlock(c, fnum2, n*sizeof(int), sizeof(int))) {
 439                         printf("unlock failed (%s)\n", cli_errstr(c));
 440                         correct = False;
 441                 }
 442         }
 443
 444         cli_close(c, fnum2);
 445         cli_unlink(c, lockfname);
 446
 447         printf("%d\n", i);
 448
 449         return correct;
 450 }
 451
 452 static BOOL run_torture(int dummy)
 453 {
 454         struct cli_state *cli;
 455         BOOL ret;
 456
 457         cli = current_cli;
 458
 459         cli_sockopt(cli, sockops);
 460
 461         ret = rw_torture(cli);
 462
 463         if (!torture_close_connection(cli)) {
 464                 ret = False;
 465         }
 466
 467         return ret;
 468 }
 469
 470 static BOOL rw_torture3(struct cli_state *c, char *lockfname)
 471 {
 472         int fnum = -1;
 473         unsigned int i = 0;
 474         char buf[131072];
 475         char buf_rd[131072];
 476         unsigned count;
 477         unsigned countprev = 0;
 478         ssize_t sent = 0;
 479         BOOL correct = True;
 480
 481         srandom(1);
 482         for (i = 0; i < sizeof(buf); i += sizeof(uint32))
 483         {
 484                 SIVAL(buf, i, sys_random());
 485         }
 486
 487         if (procnum == 0)
 488         {
 489                 fnum = cli_open(c, lockfname, O_RDWR | O_CREAT | O_EXCL,
 490                                  DENY_NONE);
 491                 if (fnum == -1) {
 492                         printf("first open read/write of %s failed (%s)\n",
 493                                         lockfname, cli_errstr(c));
 494                         return False;
 495                 }
 496         }
 497         else
 498         {
 499                 for (i = 0; i < 500 && fnum == -1; i++)
 500                 {
 501                         fnum = cli_open(c, lockfname, O_RDONLY,
 502                                          DENY_NONE);
 503                         smb_msleep(10);
 504                 }
 505                 if (fnum == -1) {
 506                         printf("second open read-only of %s failed (%s)\n",
 507                                         lockfname, cli_errstr(c));
 508                         return False;
 509                 }
 510         }
 511
 512         i = 0;
 513         for (count = 0; count < sizeof(buf); count += sent)
 514         {
 515                 if (count >= countprev) {
 516                         printf("%d %8d\r", i, count);
 517                         fflush(stdout);
 518                         i++;
 519                         countprev += (sizeof(buf) / 20);
 520                 }
 521
 522                 if (procnum == 0)
 523                 {
 524                         sent = ((unsigned)sys_random()%(20))+ 1;
 525                         if (sent > sizeof(buf) - count)
 526                         {
 527                                 sent = sizeof(buf) - count;
 528                         }
 529
 530                         if (cli_write(c, fnum, 0, buf+count, count, (size_t)sent) != sent) {
 531                                 printf("write failed (%s)\n", cli_errstr(c));
 532                                 correct = False;
 533                         }
 534                 }
 535                 else
 536                 {
 537                         sent = cli_read(c, fnum, buf_rd+count, count,
 538                                                   sizeof(buf)-count);
 539                         if (sent < 0)
 540                         {
 541                                 printf("read failed offset:%d size:%ld (%s)\n",
 542                                        count, (unsigned long)sizeof(buf)-count,
 543                                        cli_errstr(c));
 544                                 correct = False;
 545                                 sent = 0;
 546                         }
 547                         if (sent > 0)
 548                         {
 549                                 if (memcmp(buf_rd+count, buf+count, sent) != 0)
 550                                 {
 551                                         printf("read/write compare failed\n");
 552                                         printf("offset: %d req %ld recvd %ld\n", count, (unsigned long)sizeof(buf)-count, (unsigned long)sent);
 553                                         correct = False;
 554                                         break;
 555                                 }
 556                         }
 557                 }
 558
 559         }
 560
 561         if (!cli_close(c, fnum)) {
 562                 printf("close failed (%s)\n", cli_errstr(c));
 563                 correct = False;
 564         }
 565
 566         return correct;
 567 }
 568
 569 static BOOL rw_torture2(struct cli_state *c1, struct cli_state *c2)
 570 {
 571         const char *lockfname = "\\torture2.lck";
 572         int fnum1;
 573         int fnum2;
 574         int i;
 575         char buf[131072];
 576         char buf_rd[131072];
 577         BOOL correct = True;
 578         ssize_t bytes_read;
 579
 580         if (!cli_unlink(c1, lockfname)) {
 581                 printf("unlink failed (%s) (normal, this file should not exist)\n", cli_errstr(c1));
 582         }
 583
 584         fnum1 = cli_open(c1, lockfname, O_RDWR | O_CREAT | O_EXCL,
 585                          DENY_NONE);
 586         if (fnum1 == -1) {
 587                 printf("first open read/write of %s failed (%s)\n",
 588                                 lockfname, cli_errstr(c1));
 589                 return False;
 590         }
 591         fnum2 = cli_open(c2, lockfname, O_RDONLY,
 592                          DENY_NONE);
 593         if (fnum2 == -1) {
 594                 printf("second open read-only of %s failed (%s)\n",
 595                                 lockfname, cli_errstr(c2));
 596                 cli_close(c1, fnum1);
 597                 return False;
 598         }
 599
 600         for (i=0;i<torture_numops;i++)
 601         {
 602                 size_t buf_size = ((unsigned)sys_random()%(sizeof(buf)-1))+ 1;
 603                 if (i % 10 == 0) {
 604                         printf("%d\r", i); fflush(stdout);
 605                 }
 606
 607                 generate_random_buffer((unsigned char *)buf, buf_size);
 608
 609                 if (cli_write(c1, fnum1, 0, buf, 0, buf_size) != buf_size) {
 610                         printf("write failed (%s)\n", cli_errstr(c1));
 611                         correct = False;
 612                         break;
 613                 }
 614
 615                 if ((bytes_read = cli_read(c2, fnum2, buf_rd, 0, buf_size)) != buf_size) {
 616                         printf("read failed (%s)\n", cli_errstr(c2));
 617                         printf("read %d, expected %ld\n", (int)bytes_read,
 618                                (unsigned long)buf_size);
 619                         correct = False;
 620                         break;
 621                 }
 622
 623                 if (memcmp(buf_rd, buf, buf_size) != 0)
 624                 {
 625                         printf("read/write compare failed\n");
 626                         correct = False;
 627                         break;
 628                 }
 629         }
 630
 631         if (!cli_close(c2, fnum2)) {
 632                 printf("close failed (%s)\n", cli_errstr(c2));
 633                 correct = False;
 634         }
 635         if (!cli_close(c1, fnum1)) {
 636                 printf("close failed (%s)\n", cli_errstr(c1));
 637                 correct = False;
 638         }
 639
 640         if (!cli_unlink(c1, lockfname)) {
 641                 printf("unlink failed (%s)\n", cli_errstr(c1));
 642                 correct = False;
 643         }
 644
 645         return correct;
 646 }
 647
 648 static BOOL run_readwritetest(int dummy)
 649 {
 650         static struct cli_state *cli1, *cli2;
 651         BOOL test1, test2 = False;
 652
 653         if (!torture_open_connection(&cli1, 0) || !torture_open_connection(&cli2, 1)) {
 654                 return False;
 655         }
 656         cli_sockopt(cli1, sockops);
 657         cli_sockopt(cli2, sockops);
 658
 659         printf("starting readwritetest\n");
 660
 661         test1 = rw_torture2(cli1, cli2);
 662         printf("Passed readwritetest v1: %s\n", BOOLSTR(test1));
 663
 664         if (test1) {
 665                 test2 = rw_torture2(cli1, cli1);
 666                 printf("Passed readwritetest v2: %s\n", BOOLSTR(test2));
 667         }
 668
 669         if (!torture_close_connection(cli1)) {
 670                 test1 = False;
 671         }
 672
 673         if (!torture_close_connection(cli2)) {
 674                 test2 = False;
 675         }
 676
 677         return (test1 && test2);
 678 }
 679
 680 static BOOL run_readwritemulti(int dummy)
 681 {
 682         struct cli_state *cli;
 683         BOOL test;
 684
 685         cli = current_cli;
 686
 687         cli_sockopt(cli, sockops);
 688
 689         printf("run_readwritemulti: fname %s\n", randomfname);
 690         test = rw_torture3(cli, randomfname);
 691
 692         if (!torture_close_connection(cli)) {
 693                 test = False;
 694         }
 695
 696         return test;
 697 }
 698
 699 static BOOL run_readwritelarge(int dummy)
 700 {
 701         static struct cli_state *cli1;
 702         int fnum1;
 703         const char *lockfname = "\\large.dat";
 704         SMB_OFF_T fsize;
 705         char buf[126*1024];
 706         BOOL correct = True;
 707
 708         if (!torture_open_connection(&cli1, 0)) {
 709                 return False;
 710         }
 711         cli_sockopt(cli1, sockops);
 712         memset(buf,'\0',sizeof(buf));
 713
 714         cli1->max_xmit = 128*1024;
 715
 716         printf("starting readwritelarge\n");
 717
 718         cli_unlink(cli1, lockfname);
 719
 720         fnum1 = cli_open(cli1, lockfname, O_RDWR | O_CREAT | O_EXCL, DENY_NONE);
 721         if (fnum1 == -1) {
 722                 printf("open read/write of %s failed (%s)\n", lockfname, cli_errstr(cli1));
 723                 return False;
 724         }
 725
 726         cli_write(cli1, fnum1, 0, buf, 0, sizeof(buf));
 727
 728         if (!cli_qfileinfo(cli1, fnum1, NULL, &fsize, NULL, NULL, NULL, NULL, NULL)) {
 729                 printf("qfileinfo failed (%s)\n", cli_errstr(cli1));
 730                 correct = False;
 731         }
 732
 733         if (fsize == sizeof(buf))
 734                 printf("readwritelarge test 1 succeeded (size = %lx)\n",
 735                        (unsigned long)fsize);
 736         else {
 737                 printf("readwritelarge test 1 failed (size = %lx)\n",
 738                        (unsigned long)fsize);
 739                 correct = False;
 740         }
 741
 742         if (!cli_close(cli1, fnum1)) {
 743                 printf("close failed (%s)\n", cli_errstr(cli1));
 744                 correct = False;
 745         }
 746
 747         if (!cli_unlink(cli1, lockfname)) {
 748                 printf("unlink failed (%s)\n", cli_errstr(cli1));
 749                 correct = False;
 750         }
 751
 752         fnum1 = cli_open(cli1, lockfname, O_RDWR | O_CREAT | O_EXCL, DENY_NONE);
 753         if (fnum1 == -1) {
 754                 printf("open read/write of %s failed (%s)\n", lockfname, cli_errstr(cli1));
 755                 return False;
 756         }
 757
 758         cli1->max_xmit = 4*1024;
 759
 760         cli_smbwrite(cli1, fnum1, buf, 0, sizeof(buf));
 761
 762         if (!cli_qfileinfo(cli1, fnum1, NULL, &fsize, NULL, NULL, NULL, NULL, NULL)) {
 763                 printf("qfileinfo failed (%s)\n", cli_errstr(cli1));
 764                 correct = False;
 765         }
 766
 767         if (fsize == sizeof(buf))
 768                 printf("readwritelarge test 2 succeeded (size = %lx)\n",
 769                        (unsigned long)fsize);
 770         else {
 771                 printf("readwritelarge test 2 failed (size = %lx)\n",
 772                        (unsigned long)fsize);
 773                 correct = False;
 774         }
 775
 776 #if 0
 777         /* ToDo - set allocation. JRA */
 778         if(!cli_set_allocation_size(cli1, fnum1, 0)) {
 779                 printf("set allocation size to zero failed (%s)\n", cli_errstr(&cli1));
 780                 return False;
 781         }
 782         if (!cli_qfileinfo(cli1, fnum1, NULL, &fsize, NULL, NULL, NULL, NULL, NULL)) {
 783                 printf("qfileinfo failed (%s)\n", cli_errstr(cli1));
 784                 correct = False;
 785         }
 786         if (fsize != 0)
 787                 printf("readwritelarge test 3 (truncate test) succeeded (size = %x)\n", fsize);
 788 #endif
 789
 790         if (!cli_close(cli1, fnum1)) {
 791                 printf("close failed (%s)\n", cli_errstr(cli1));
 792                 correct = False;
 793         }
 794
 795         if (!torture_close_connection(cli1)) {
 796                 correct = False;
 797         }
 798         return correct;
 799 }
 800
 801 int line_count = 0;
 802 int nbio_id;
 803
 804 #define ival(s) strtol(s, NULL, 0)
 805
 806 /* run a test that simulates an approximate netbench client load */
 807 static BOOL run_netbench(int client)
 808 {
 809         struct cli_state *cli;
 810         int i;
 811         pstring line;
 812         char cname[20];
 813         FILE *f;
 814         const char *params[20];
 815         BOOL correct = True;
 816
 817         cli = current_cli;
 818
 819         nbio_id = client;
 820
 821         cli_sockopt(cli, sockops);
 822
 823         nb_setup(cli);
 824
 825         slprintf(cname,sizeof(cname)-1, "client%d", client);
 826
 827         f = fopen(client_txt, "r");
 828
 829         if (!f) {
 830                 perror(client_txt);
 831                 return False;
 832         }
 833
 834         while (fgets(line, sizeof(line)-1, f)) {
 835                 line_count++;
 836
 837                 line[strlen(line)-1] = 0;
 838
 839                 /* printf("[%d] %s\n", line_count, line); */
 840
 841                 all_string_sub(line,"client1", cname, sizeof(line));
 842
 843                 /* parse the command parameters */
 844                 params[0] = strtok(line," ");
 845                 i = 0;
 846                 while (params[i]) params[++i] = strtok(NULL," ");
 847
 848                 params[i] = "";
 849
 850                 if (i < 2) continue;
 851
 852                 if (!strncmp(params[0],"SMB", 3)) {
 853                         printf("ERROR: You are using a dbench 1 load file\n");
 854                         exit(1);
 855                 }
 856
 857                 if (!strcmp(params[0],"NTCreateX")) {
 858                         nb_createx(params[1], ival(params[2]), ival(params[3]),
 859                                    ival(params[4]));
 860                 } else if (!strcmp(params[0],"Close")) {
 861                         nb_close(ival(params[1]));
 862                 } else if (!strcmp(params[0],"Rename")) {
 863                         nb_rename(params[1], params[2]);
 864                 } else if (!strcmp(params[0],"Unlink")) {
 865                         nb_unlink(params[1]);
 866                 } else if (!strcmp(params[0],"Deltree")) {
 867                         nb_deltree(params[1]);
 868                 } else if (!strcmp(params[0],"Rmdir")) {
 869                         nb_rmdir(params[1]);
 870                 } else if (!strcmp(params[0],"QUERY_PATH_INFORMATION")) {
 871                         nb_qpathinfo(params[1]);
 872                 } else if (!strcmp(params[0],"QUERY_FILE_INFORMATION")) {
 873                         nb_qfileinfo(ival(params[1]));
 874                 } else if (!strcmp(params[0],"QUERY_FS_INFORMATION")) {
 875                         nb_qfsinfo(ival(params[1]));
 876                 } else if (!strcmp(params[0],"FIND_FIRST")) {
 877                         nb_findfirst(params[1]);
 878                 } else if (!strcmp(params[0],"WriteX")) {
 879                         nb_writex(ival(params[1]),
 880                                   ival(params[2]), ival(params[3]), ival(params[4]));
 881                 } else if (!strcmp(params[0],"ReadX")) {
 882                         nb_readx(ival(params[1]),
 883                                   ival(params[2]), ival(params[3]), ival(params[4]));
 884                 } else if (!strcmp(params[0],"Flush")) {
 885                         nb_flush(ival(params[1]));
 886                 } else {
 887                         printf("Unknown operation %s\n", params[0]);
 888                         exit(1);
 889                 }
 890         }
 891         fclose(f);
 892
 893         nb_cleanup();
 894
 895         if (!torture_close_connection(cli)) {
 896                 correct = False;
 897         }
 898
 899         return correct;
 900 }
 901
 902
 903 /* run a test that simulates an approximate netbench client load */
 904 static BOOL run_nbench(int dummy)
 905 {
 906         double t;
 907         BOOL correct = True;
 908
 909         nbio_shmem(nprocs);
 910
 911         nbio_id = -1;
 912
 913         signal(SIGALRM, nb_alarm);
 914         alarm(1);
 915         t = create_procs(run_netbench, &correct);
 916         alarm(0);
 917
 918         printf("\nThroughput %g MB/sec\n",
 919                1.0e-6 * nbio_total() / t);
 920         return correct;
 921 }
 922
 923
 924 /*
 925   This test checks for two things:
 926
 927   1) correct support for retaining locks over a close (ie. the server
 928      must not use posix semantics)
 929   2) support for lock timeouts
 930  */
 931 static BOOL run_locktest1(int dummy)
 932 {
 933         struct cli_state *cli1, *cli2;
 934         const char *fname = "\\lockt1.lck";
 935         int fnum1, fnum2, fnum3;
 936         time_t t1, t2;
 937         unsigned lock_timeout;
 938
 939         if (!torture_open_connection(&cli1, 0) || !torture_open_connection(&cli2, 1)) {
 940                 return False;
 941         }
 942         cli_sockopt(cli1, sockops);
 943         cli_sockopt(cli2, sockops);
 944
 945         printf("starting locktest1\n");
 946
 947         cli_unlink(cli1, fname);
 948
 949         fnum1 = cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
 950         if (fnum1 == -1) {
 951                 printf("open of %s failed (%s)\n", fname, cli_errstr(cli1));
 952                 return False;
 953         }
 954         fnum2 = cli_open(cli1, fname, O_RDWR, DENY_NONE);
 955         if (fnum2 == -1) {
 956                 printf("open2 of %s failed (%s)\n", fname, cli_errstr(cli1));
 957                 return False;
 958         }
 959         fnum3 = cli_open(cli2, fname, O_RDWR, DENY_NONE);
 960         if (fnum3 == -1) {
 961                 printf("open3 of %s failed (%s)\n", fname, cli_errstr(cli2));
 962                 return False;
 963         }
 964
 965         if (!cli_lock(cli1, fnum1, 0, 4, 0, WRITE_LOCK)) {
 966                 printf("lock1 failed (%s)\n", cli_errstr(cli1));
 967                 return False;
 968         }
 969
 970
 971         if (cli_lock(cli2, fnum3, 0, 4, 0, WRITE_LOCK)) {
 972                 printf("lock2 succeeded! This is a locking bug\n");
 973                 return False;
 974         } else {
 975                 if (!check_error(__LINE__, cli2, ERRDOS, ERRlock,
 976                                  NT_STATUS_LOCK_NOT_GRANTED)) return False;
 977         }
 978
 979
 980         lock_timeout = (1 + (random() % 20));
 981         printf("Testing lock timeout with timeout=%u\n", lock_timeout);
 982         t1 = time(NULL);
 983         if (cli_lock(cli2, fnum3, 0, 4, lock_timeout * 1000, WRITE_LOCK)) {
 984                 printf("lock3 succeeded! This is a locking bug\n");
 985                 return False;
 986         } else {
 987                 if (!check_error(__LINE__, cli2, ERRDOS, ERRlock,
 988                                  NT_STATUS_FILE_LOCK_CONFLICT)) return False;
 989         }
 990         t2 = time(NULL);
 991
 992         if (ABS(t2 - t1) < lock_timeout-1) {
 993                 printf("error: This server appears not to support timed lock requests\n");
 994         }
 995
 996         printf("server slept for %u seconds for a %u second timeout\n",
 997                (unsigned int)(t2-t1), lock_timeout);
 998
 999         if (!cli_close(cli1, fnum2)) {
1000                 printf("close1 failed (%s)\n", cli_errstr(cli1));
1001                 return False;
1002         }
1003
1004         if (cli_lock(cli2, fnum3, 0, 4, 0, WRITE_LOCK)) {
1005                 printf("lock4 succeeded! This is a locking bug\n");
1006                 return False;
1007         } else {
1008                 if (!check_error(__LINE__, cli2, ERRDOS, ERRlock,
1009                                  NT_STATUS_FILE_LOCK_CONFLICT)) return False;
1010         }
1011
1012         if (!cli_close(cli1, fnum1)) {
1013                 printf("close2 failed (%s)\n", cli_errstr(cli1));
1014                 return False;
1015         }
1016
1017         if (!cli_close(cli2, fnum3)) {
1018                 printf("close3 failed (%s)\n", cli_errstr(cli2));
1019                 return False;
1020         }
1021
1022         if (!cli_unlink(cli1, fname)) {
1023                 printf("unlink failed (%s)\n", cli_errstr(cli1));
1024                 return False;
1025         }
1026
1027
1028         if (!torture_close_connection(cli1)) {
1029                 return False;
1030         }
1031
1032         if (!torture_close_connection(cli2)) {
1033                 return False;
1034         }
1035
1036         printf("Passed locktest1\n");
1037         return True;
1038 }
1039
1040 /*
1041   this checks to see if a secondary tconx can use open files from an
1042   earlier tconx
1043  */
1044 static BOOL run_tcon_test(int dummy)
1045 {
1046         static struct cli_state *cli;
1047         const char *fname = "\\tcontest.tmp";
1048         int fnum1;
1049         uint16 cnum1, cnum2, cnum3;
1050         uint16 vuid1, vuid2;
1051         char buf[4];
1052         BOOL ret = True;
1053
1054         memset(buf, '\0', sizeof(buf));
1055
1056         if (!torture_open_connection(&cli, 0)) {
1057                 return False;
1058         }
1059         cli_sockopt(cli, sockops);
1060
1061         printf("starting tcontest\n");
1062
1063         cli_unlink(cli, fname);
1064
1065         fnum1 = cli_open(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
1066         if (fnum1 == -1) {
1067                 printf("open of %s failed (%s)\n", fname, cli_errstr(cli));
1068                 return False;
1069         }
1070
1071         cnum1 = cli->cnum;
1072         vuid1 = cli->vuid;
1073
1074         if (cli_write(cli, fnum1, 0, buf, 130, 4) != 4) {
1075                 printf("initial write failed (%s)", cli_errstr(cli));
1076                 return False;
1077         }
1078
1079         if (!cli_send_tconX(cli, share, "?????",
1080                             password, strlen(password)+1)) {
1081                 printf("%s refused 2nd tree connect (%s)\n", host,
1082                            cli_errstr(cli));
1083                 cli_shutdown(cli);
1084                 return False;
1085         }
1086
1087         cnum2 = cli->cnum;
1088         cnum3 = MAX(cnum1, cnum2) + 1; /* any invalid number */
1089         vuid2 = cli->vuid + 1;
1090
1091         /* try a write with the wrong tid */
1092         cli->cnum = cnum2;
1093
1094         if (cli_write(cli, fnum1, 0, buf, 130, 4) == 4) {
1095                 printf("* server allows write with wrong TID\n");
1096                 ret = False;
1097         } else {
1098                 printf("server fails write with wrong TID : %s\n", cli_errstr(cli));
1099         }
1100
1101
1102         /* try a write with an invalid tid */
1103         cli->cnum = cnum3;
1104
1105         if (cli_write(cli, fnum1, 0, buf, 130, 4) == 4) {
1106                 printf("* server allows write with invalid TID\n");
1107                 ret = False;
1108         } else {
1109                 printf("server fails write with invalid TID : %s\n", cli_errstr(cli));
1110         }
1111
1112         /* try a write with an invalid vuid */
1113         cli->vuid = vuid2;
1114         cli->cnum = cnum1;
1115
1116         if (cli_write(cli, fnum1, 0, buf, 130, 4) == 4) {
1117                 printf("* server allows write with invalid VUID\n");
1118                 ret = False;
1119         } else {
1120                 printf("server fails write with invalid VUID : %s\n", cli_errstr(cli));
1121         }
1122
1123         cli->cnum = cnum1;
1124         cli->vuid = vuid1;
1125
1126         if (!cli_close(cli, fnum1)) {
1127                 printf("close failed (%s)\n", cli_errstr(cli));
1128                 return False;
1129         }
1130
1131         cli->cnum = cnum2;
1132
1133         if (!cli_tdis(cli)) {
1134                 printf("secondary tdis failed (%s)\n", cli_errstr(cli));
1135                 return False;
1136         }
1137
1138         cli->cnum = cnum1;
1139
1140         if (!torture_close_connection(cli)) {
1141                 return False;
1142         }
1143
1144         return ret;
1145 }
1146
1147
1148 /*
1149  checks for old style tcon support
1150  */
1151 static BOOL run_tcon2_test(int dummy)
1152 {
1153         static struct cli_state *cli;
1154         uint16 cnum, max_xmit;
1155         char *service;
1156         NTSTATUS status;
1157
1158         if (!torture_open_connection(&cli, 0)) {
1159                 return False;
1160         }
1161         cli_sockopt(cli, sockops);
1162
1163         printf("starting tcon2 test\n");
1164
1165         asprintf(&service, "\\\\%s\\%s", host, share);
1166
1167         status = cli_raw_tcon(cli, service, password, "?????", &max_xmit, &cnum);
1168
1169         if (!NT_STATUS_IS_OK(status)) {
1170                 printf("tcon2 failed : %s\n", cli_errstr(cli));
1171         } else {
1172                 printf("tcon OK : max_xmit=%d cnum=%d tid=%d\n",
1173                        (int)max_xmit, (int)cnum, SVAL(cli->inbuf, smb_tid));
1174         }
1175
1176         if (!torture_close_connection(cli)) {
1177                 return False;
1178         }
1179
1180         printf("Passed tcon2 test\n");
1181         return True;
1182 }
1183
1184 static BOOL tcon_devtest(struct cli_state *cli,
1185                          const char *myshare, const char *devtype,
1186                          const char *return_devtype,
1187                          NTSTATUS expected_error)
1188 {
1189         BOOL status;
1190         BOOL ret;
1191
1192         status = cli_send_tconX(cli, myshare, devtype,
1193                                 password, strlen(password)+1);
1194
1195         if (NT_STATUS_IS_OK(expected_error)) {
1196                 if (status) {
1197                         if (strcmp(cli->dev, return_devtype) == 0) {
1198                                 ret = True;
1199                         } else {
1200                                 printf("tconX to share %s with type %s "
1201                                        "succeeded but returned the wrong "
1202                                        "device type (got [%s] but should have got [%s])\n",
1203                                        myshare, devtype, cli->dev, return_devtype);
1204                                 ret = False;
1205                         }
1206                 } else {
1207                         printf("tconX to share %s with type %s "
1208                                "should have succeeded but failed\n",
1209                                myshare, devtype);
1210                         ret = False;
1211                 }
1212                 cli_tdis(cli);
1213         } else {
1214                 if (status) {
1215                         printf("tconx to share %s with type %s "
1216                                "should have failed but succeeded\n",
1217                                myshare, devtype);
1218                         ret = False;
1219                 } else {
1220                         if (NT_STATUS_EQUAL(cli_nt_error(cli),
1221                                             expected_error)) {
1222                                 ret = True;
1223                         } else {
1224                                 printf("Returned unexpected error\n");
1225                                 ret = False;
1226                         }
1227                 }
1228         }
1229         return ret;
1230 }
1231
1232 /*
1233  checks for correct tconX support
1234  */
1235 static BOOL run_tcon_devtype_test(int dummy)
1236 {
1237         static struct cli_state *cli1 = NULL;
1238         BOOL retry;
1239         int flags = 0;
1240         NTSTATUS status;
1241         BOOL ret = True;
1242
1243         status = cli_full_connection(&cli1, myname,
1244                                      host, NULL, port_to_use,
1245                                      NULL, NULL,
1246                                      username, workgroup,
1247                                      password, flags, Undefined, &retry);
1248
1249         if (!NT_STATUS_IS_OK(status)) {
1250                 printf("could not open connection\n");
1251                 return False;
1252         }
1253
1254         if (!tcon_devtest(cli1, "IPC$", "A:", NULL, NT_STATUS_BAD_DEVICE_TYPE))
1255                 ret = False;
1256
1257         if (!tcon_devtest(cli1, "IPC$", "?????", "IPC", NT_STATUS_OK))
1258                 ret = False;
1259
1260         if (!tcon_devtest(cli1, "IPC$", "LPT:", NULL, NT_STATUS_BAD_DEVICE_TYPE))
1261                 ret = False;
1262
1263         if (!tcon_devtest(cli1, "IPC$", "IPC", "IPC", NT_STATUS_OK))
1264                 ret = False;
1265
1266         if (!tcon_devtest(cli1, "IPC$", "FOOBA", NULL, NT_STATUS_BAD_DEVICE_TYPE))
1267                 ret = False;
1268
1269         if (!tcon_devtest(cli1, share, "A:", "A:", NT_STATUS_OK))
1270                 ret = False;
1271
1272         if (!tcon_devtest(cli1, share, "?????", "A:", NT_STATUS_OK))
1273                 ret = False;
1274
1275         if (!tcon_devtest(cli1, share, "LPT:", NULL, NT_STATUS_BAD_DEVICE_TYPE))
1276                 ret = False;
1277
1278         if (!tcon_devtest(cli1, share, "IPC", NULL, NT_STATUS_BAD_DEVICE_TYPE))
1279                 ret = False;
1280
1281         if (!tcon_devtest(cli1, share, "FOOBA", NULL, NT_STATUS_BAD_DEVICE_TYPE))
1282                 ret = False;
1283
1284         cli_shutdown(cli1);
1285
1286         if (ret)
1287                 printf("Passed tcondevtest\n");
1288
1289         return ret;
1290 }
1291
1292
1293 /*
1294   This test checks that
1295
1296   1) the server supports multiple locking contexts on the one SMB
1297   connection, distinguished by PID.
1298
1299   2) the server correctly fails overlapping locks made by the same PID (this
1300      goes against POSIX behaviour, which is why it is tricky to implement)
1301
1302   3) the server denies unlock requests by an incorrect client PID
1303 */
1304 static BOOL run_locktest2(int dummy)
1305 {
1306         static struct cli_state *cli;
1307         const char *fname = "\\lockt2.lck";
1308         int fnum1, fnum2, fnum3;
1309         BOOL correct = True;
1310
1311         if (!torture_open_connection(&cli, 0)) {
1312                 return False;
1313         }
1314
1315         cli_sockopt(cli, sockops);
1316
1317         printf("starting locktest2\n");
1318
1319         cli_unlink(cli, fname);
1320
1321         cli_setpid(cli, 1);
1322
1323         fnum1 = cli_open(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
1324         if (fnum1 == -1) {
1325                 printf("open of %s failed (%s)\n", fname, cli_errstr(cli));
1326                 return False;
1327         }
1328
1329         fnum2 = cli_open(cli, fname, O_RDWR, DENY_NONE);
1330         if (fnum2 == -1) {
1331                 printf("open2 of %s failed (%s)\n", fname, cli_errstr(cli));
1332                 return False;
1333         }
1334
1335         cli_setpid(cli, 2);
1336
1337         fnum3 = cli_open(cli, fname, O_RDWR, DENY_NONE);
1338         if (fnum3 == -1) {
1339                 printf("open3 of %s failed (%s)\n", fname, cli_errstr(cli));
1340                 return False;
1341         }
1342
1343         cli_setpid(cli, 1);
1344
1345         if (!cli_lock(cli, fnum1, 0, 4, 0, WRITE_LOCK)) {
1346                 printf("lock1 failed (%s)\n", cli_errstr(cli));
1347                 return False;
1348         }
1349
1350         if (cli_lock(cli, fnum1, 0, 4, 0, WRITE_LOCK)) {
1351                 printf("WRITE lock1 succeeded! This is a locking bug\n");
1352                 correct = False;
1353         } else {
1354                 if (!check_error(__LINE__, cli, ERRDOS, ERRlock,
1355                                  NT_STATUS_LOCK_NOT_GRANTED)) return False;
1356         }
1357
1358         if (cli_lock(cli, fnum2, 0, 4, 0, WRITE_LOCK)) {
1359                 printf("WRITE lock2 succeeded! This is a locking bug\n");
1360                 correct = False;
1361         } else {
1362                 if (!check_error(__LINE__, cli, ERRDOS, ERRlock,
1363                                  NT_STATUS_LOCK_NOT_GRANTED)) return False;
1364         }
1365
1366         if (cli_lock(cli, fnum2, 0, 4, 0, READ_LOCK)) {
1367                 printf("READ lock2 succeeded! This is a locking bug\n");
1368                 correct = False;
1369         } else {
1370                 if (!check_error(__LINE__, cli, ERRDOS, ERRlock,
1371                                  NT_STATUS_FILE_LOCK_CONFLICT)) return False;
1372         }
1373
1374         if (!cli_lock(cli, fnum1, 100, 4, 0, WRITE_LOCK)) {
1375                 printf("lock at 100 failed (%s)\n", cli_errstr(cli));
1376         }
1377         cli_setpid(cli, 2);
1378         if (cli_unlock(cli, fnum1, 100, 4)) {
1379                 printf("unlock at 100 succeeded! This is a locking bug\n");
1380                 correct = False;
1381         }
1382
1383         if (cli_unlock(cli, fnum1, 0, 4)) {
1384                 printf("unlock1 succeeded! This is a locking bug\n");
1385                 correct = False;
1386         } else {
1387                 if (!check_error(__LINE__, cli,
1388                                  ERRDOS, ERRlock,
1389                                  NT_STATUS_RANGE_NOT_LOCKED)) return False;
1390         }
1391
1392         if (cli_unlock(cli, fnum1, 0, 8)) {
1393                 printf("unlock2 succeeded! This is a locking bug\n");
1394                 correct = False;
1395         } else {
1396                 if (!check_error(__LINE__, cli,
1397                                  ERRDOS, ERRlock,
1398                                  NT_STATUS_RANGE_NOT_LOCKED)) return False;
1399         }
1400
1401         if (cli_lock(cli, fnum3, 0, 4, 0, WRITE_LOCK)) {
1402                 printf("lock3 succeeded! This is a locking bug\n");
1403                 correct = False;
1404         } else {
1405                 if (!check_error(__LINE__, cli, ERRDOS, ERRlock, NT_STATUS_LOCK_NOT_GRANTED)) return False;
1406         }
1407
1408         cli_setpid(cli, 1);
1409
1410         if (!cli_close(cli, fnum1)) {
1411                 printf("close1 failed (%s)\n", cli_errstr(cli));
1412                 return False;
1413         }
1414
1415         if (!cli_close(cli, fnum2)) {
1416                 printf("close2 failed (%s)\n", cli_errstr(cli));
1417                 return False;
1418         }
1419
1420         if (!cli_close(cli, fnum3)) {
1421                 printf("close3 failed (%s)\n", cli_errstr(cli));
1422                 return False;
1423         }
1424
1425         if (!torture_close_connection(cli)) {
1426                 correct = False;
1427         }
1428
1429         printf("locktest2 finished\n");
1430
1431         return correct;
1432 }
1433
1434
1435 /*
1436   This test checks that
1437
1438   1) the server supports the full offset range in lock requests
1439 */
1440 static BOOL run_locktest3(int dummy)
1441 {
1442         static struct cli_state *cli1, *cli2;
1443         const char *fname = "\\lockt3.lck";
1444         int fnum1, fnum2, i;
1445         uint32 offset;
1446         BOOL correct = True;
1447
1448 #define NEXT_OFFSET offset += (~(uint32)0) / torture_numops
1449
1450         if (!torture_open_connection(&cli1, 0) || !torture_open_connection(&cli2, 1)) {
1451                 return False;
1452         }
1453         cli_sockopt(cli1, sockops);
1454         cli_sockopt(cli2, sockops);
1455
1456         printf("starting locktest3\n");
1457
1458         cli_unlink(cli1, fname);
1459
1460         fnum1 = cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
1461         if (fnum1 == -1) {
1462                 printf("open of %s failed (%s)\n", fname, cli_errstr(cli1));
1463                 return False;
1464         }
1465         fnum2 = cli_open(cli2, fname, O_RDWR, DENY_NONE);
1466         if (fnum2 == -1) {
1467                 printf("open2 of %s failed (%s)\n", fname, cli_errstr(cli2));
1468                 return False;
1469         }
1470
1471         for (offset=i=0;i<torture_numops;i++) {
1472                 NEXT_OFFSET;
1473                 if (!cli_lock(cli1, fnum1, offset-1, 1, 0, WRITE_LOCK)) {
1474                         printf("lock1 %d failed (%s)\n",
1475                                i,
1476                                cli_errstr(cli1));
1477                         return False;
1478                 }
1479
1480                 if (!cli_lock(cli2, fnum2, offset-2, 1, 0, WRITE_LOCK)) {
1481                         printf("lock2 %d failed (%s)\n",
1482                                i,
1483                                cli_errstr(cli1));
1484                         return False;
1485                 }
1486         }
1487
1488         for (offset=i=0;i<torture_numops;i++) {
1489                 NEXT_OFFSET;
1490
1491                 if (cli_lock(cli1, fnum1, offset-2, 1, 0, WRITE_LOCK)) {
1492                         printf("error: lock1 %d succeeded!\n", i);
1493                         return False;
1494                 }
1495
1496                 if (cli_lock(cli2, fnum2, offset-1, 1, 0, WRITE_LOCK)) {
1497                         printf("error: lock2 %d succeeded!\n", i);
1498                         return False;
1499                 }
1500
1501                 if (cli_lock(cli1, fnum1, offset-1, 1, 0, WRITE_LOCK)) {
1502                         printf("error: lock3 %d succeeded!\n", i);
1503                         return False;
1504                 }
1505
1506                 if (cli_lock(cli2, fnum2, offset-2, 1, 0, WRITE_LOCK)) {
1507                         printf("error: lock4 %d succeeded!\n", i);
1508                         return False;
1509                 }
1510         }
1511
1512         for (offset=i=0;i<torture_numops;i++) {
1513                 NEXT_OFFSET;
1514
1515                 if (!cli_unlock(cli1, fnum1, offset-1, 1)) {
1516                         printf("unlock1 %d failed (%s)\n",
1517                                i,
1518                                cli_errstr(cli1));
1519                         return False;
1520                 }
1521
1522                 if (!cli_unlock(cli2, fnum2, offset-2, 1)) {
1523                         printf("unlock2 %d failed (%s)\n",
1524                                i,
1525                                cli_errstr(cli1));
1526                         return False;
1527                 }
1528         }
1529
1530         if (!cli_close(cli1, fnum1)) {
1531                 printf("close1 failed (%s)\n", cli_errstr(cli1));
1532                 return False;
1533         }
1534
1535         if (!cli_close(cli2, fnum2)) {
1536                 printf("close2 failed (%s)\n", cli_errstr(cli2));
1537                 return False;
1538         }
1539
1540         if (!cli_unlink(cli1, fname)) {
1541                 printf("unlink failed (%s)\n", cli_errstr(cli1));
1542                 return False;
1543         }
1544
1545         if (!torture_close_connection(cli1)) {
1546                 correct = False;
1547         }
1548
1549         if (!torture_close_connection(cli2)) {
1550                 correct = False;
1551         }
1552
1553         printf("finished locktest3\n");
1554
1555         return correct;
1556 }
1557
1558 #define EXPECTED(ret, v) if ((ret) != (v)) { \
1559         printf("** "); correct = False; \
1560         }
1561
1562 /*
1563   looks at overlapping locks
1564 */
1565 static BOOL run_locktest4(int dummy)
1566 {
1567         static struct cli_state *cli1, *cli2;
1568         const char *fname = "\\lockt4.lck";
1569         int fnum1, fnum2, f;
1570         BOOL ret;
1571         char buf[1000];
1572         BOOL correct = True;
1573
1574         if (!torture_open_connection(&cli1, 0) || !torture_open_connection(&cli2, 1)) {
1575                 return False;
1576         }
1577
1578         cli_sockopt(cli1, sockops);
1579         cli_sockopt(cli2, sockops);
1580
1581         printf("starting locktest4\n");
1582
1583         cli_unlink(cli1, fname);
1584
1585         fnum1 = cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
1586         fnum2 = cli_open(cli2, fname, O_RDWR, DENY_NONE);
1587
1588         memset(buf, 0, sizeof(buf));
1589
1590         if (cli_write(cli1, fnum1, 0, buf, 0, sizeof(buf)) != sizeof(buf)) {
1591                 printf("Failed to create file\n");
1592                 correct = False;
1593                 goto fail;
1594         }
1595
1596         ret = cli_lock(cli1, fnum1, 0, 4, 0, WRITE_LOCK) &&
1597               cli_lock(cli1, fnum1, 2, 4, 0, WRITE_LOCK);
1598         EXPECTED(ret, False);
1599         printf("the same process %s set overlapping write locks\n", ret?"can":"cannot");
1600
1601         ret = cli_lock(cli1, fnum1, 10, 4, 0, READ_LOCK) &&
1602               cli_lock(cli1, fnum1, 12, 4, 0, READ_LOCK);
1603         EXPECTED(ret, True);
1604         printf("the same process %s set overlapping read locks\n", ret?"can":"cannot");
1605
1606         ret = cli_lock(cli1, fnum1, 20, 4, 0, WRITE_LOCK) &&
1607               cli_lock(cli2, fnum2, 22, 4, 0, WRITE_LOCK);
1608         EXPECTED(ret, False);
1609         printf("a different connection %s set overlapping write locks\n", ret?"can":"cannot");
1610
1611         ret = cli_lock(cli1, fnum1, 30, 4, 0, READ_LOCK) &&
1612               cli_lock(cli2, fnum2, 32, 4, 0, READ_LOCK);
1613         EXPECTED(ret, True);
1614         printf("a different connection %s set overlapping read locks\n", ret?"can":"cannot");
1615
1616         ret = (cli_setpid(cli1, 1), cli_lock(cli1, fnum1, 40, 4, 0, WRITE_LOCK)) &&
1617               (cli_setpid(cli1, 2), cli_lock(cli1, fnum1, 42, 4, 0, WRITE_LOCK));
1618         EXPECTED(ret, False);
1619         printf("a different pid %s set overlapping write locks\n", ret?"can":"cannot");
1620
1621         ret = (cli_setpid(cli1, 1), cli_lock(cli1, fnum1, 50, 4, 0, READ_LOCK)) &&
1622               (cli_setpid(cli1, 2), cli_lock(cli1, fnum1, 52, 4, 0, READ_LOCK));
1623         EXPECTED(ret, True);
1624         printf("a different pid %s set overlapping read locks\n", ret?"can":"cannot");
1625
1626         ret = cli_lock(cli1, fnum1, 60, 4, 0, READ_LOCK) &&
1627               cli_lock(cli1, fnum1, 60, 4, 0, READ_LOCK);
1628         EXPECTED(ret, True);
1629         printf("the same process %s set the same read lock twice\n", ret?"can":"cannot");
1630
1631         ret = cli_lock(cli1, fnum1, 70, 4, 0, WRITE_LOCK) &&
1632               cli_lock(cli1, fnum1, 70, 4, 0, WRITE_LOCK);
1633         EXPECTED(ret, False);
1634         printf("the same process %s set the same write lock twice\n", ret?"can":"cannot");
1635
1636         ret = cli_lock(cli1, fnum1, 80, 4, 0, READ_LOCK) &&
1637               cli_lock(cli1, fnum1, 80, 4, 0, WRITE_LOCK);
1638         EXPECTED(ret, False);
1639         printf("the same process %s overlay a read lock with a write lock\n", ret?"can":"cannot");
1640
1641         ret = cli_lock(cli1, fnum1, 90, 4, 0, WRITE_LOCK) &&
1642               cli_lock(cli1, fnum1, 90, 4, 0, READ_LOCK);
1643         EXPECTED(ret, True);
1644         printf("the same process %s overlay a write lock with a read lock\n", ret?"can":"cannot");
1645
1646         ret = (cli_setpid(cli1, 1), cli_lock(cli1, fnum1, 100, 4, 0, WRITE_LOCK)) &&
1647               (cli_setpid(cli1, 2), cli_lock(cli1, fnum1, 100, 4, 0, READ_LOCK));
1648         EXPECTED(ret, False);
1649         printf("a different pid %s overlay a write lock with a read lock\n", ret?"can":"cannot");
1650
1651         ret = cli_lock(cli1, fnum1, 110, 4, 0, READ_LOCK) &&
1652               cli_lock(cli1, fnum1, 112, 4, 0, READ_LOCK) &&
1653               cli_unlock(cli1, fnum1, 110, 6);
1654         EXPECTED(ret, False);
1655         printf("the same process %s coalesce read locks\n", ret?"can":"cannot");
1656
1657
1658         ret = cli_lock(cli1, fnum1, 120, 4, 0, WRITE_LOCK) &&
1659               (cli_read(cli2, fnum2, buf, 120, 4) == 4);
1660         EXPECTED(ret, False);
1661         printf("this server %s strict write locking\n", ret?"doesn't do":"does");
1662
1663         ret = cli_lock(cli1, fnum1, 130, 4, 0, READ_LOCK) &&
1664               (cli_write(cli2, fnum2, 0, buf, 130, 4) == 4);
1665         EXPECTED(ret, False);
1666         printf("this server %s strict read locking\n", ret?"doesn't do":"does");
1667
1668
1669         ret = cli_lock(cli1, fnum1, 140, 4, 0, READ_LOCK) &&
1670               cli_lock(cli1, fnum1, 140, 4, 0, READ_LOCK) &&
1671               cli_unlock(cli1, fnum1, 140, 4) &&
1672               cli_unlock(cli1, fnum1, 140, 4);
1673         EXPECTED(ret, True);
1674         printf("this server %s do recursive read locking\n", ret?"does":"doesn't");
1675
1676
1677         ret = cli_lock(cli1, fnum1, 150, 4, 0, WRITE_LOCK) &&
1678               cli_lock(cli1, fnum1, 150, 4, 0, READ_LOCK) &&
1679               cli_unlock(cli1, fnum1, 150, 4) &&
1680               (cli_read(cli2, fnum2, buf, 150, 4) == 4) &&
1681               !(cli_write(cli2, fnum2, 0, buf, 150, 4) == 4) &&
1682               cli_unlock(cli1, fnum1, 150, 4);
1683         EXPECTED(ret, True);
1684         printf("this server %s do recursive lock overlays\n", ret?"does":"doesn't");
1685
1686         ret = cli_lock(cli1, fnum1, 160, 4, 0, READ_LOCK) &&
1687               cli_unlock(cli1, fnum1, 160, 4) &&
1688               (cli_write(cli2, fnum2, 0, buf, 160, 4) == 4) &&
1689               (cli_read(cli2, fnum2, buf, 160, 4) == 4);
1690         EXPECTED(ret, True);
1691         printf("the same process %s remove a read lock using write locking\n", ret?"can":"cannot");
1692
1693         ret = cli_lock(cli1, fnum1, 170, 4, 0, WRITE_LOCK) &&
1694               cli_unlock(cli1, fnum1, 170, 4) &&
1695               (cli_write(cli2, fnum2, 0, buf, 170, 4) == 4) &&
1696               (cli_read(cli2, fnum2, buf, 170, 4) == 4);
1697         EXPECTED(ret, True);
1698         printf("the same process %s remove a write lock using read locking\n", ret?"can":"cannot");
1699
1700         ret = cli_lock(cli1, fnum1, 190, 4, 0, WRITE_LOCK) &&
1701               cli_lock(cli1, fnum1, 190, 4, 0, READ_LOCK) &&
1702               cli_unlock(cli1, fnum1, 190, 4) &&
1703               !(cli_write(cli2, fnum2, 0, buf, 190, 4) == 4) &&
1704               (cli_read(cli2, fnum2, buf, 190, 4) == 4);
1705         EXPECTED(ret, True);
1706         printf("the same process %s remove the first lock first\n", ret?"does":"doesn't");
1707
1708         cli_close(cli1, fnum1);
1709         cli_close(cli2, fnum2);
1710         fnum1 = cli_open(cli1, fname, O_RDWR, DENY_NONE);
1711         f = cli_open(cli1, fname, O_RDWR, DENY_NONE);
1712         ret = cli_lock(cli1, fnum1, 0, 8, 0, READ_LOCK) &&
1713               cli_lock(cli1, f, 0, 1, 0, READ_LOCK) &&
1714               cli_close(cli1, fnum1) &&
1715               ((fnum1 = cli_open(cli1, fname, O_RDWR, DENY_NONE)) != -1) &&
1716               cli_lock(cli1, fnum1, 7, 1, 0, WRITE_LOCK);
1717         cli_close(cli1, f);
1718         cli_close(cli1, fnum1);
1719         EXPECTED(ret, True);
1720         printf("the server %s have the NT byte range lock bug\n", !ret?"does":"doesn't");
1721
1722  fail:
1723         cli_close(cli1, fnum1);
1724         cli_close(cli2, fnum2);
1725         cli_unlink(cli1, fname);
1726         torture_close_connection(cli1);
1727         torture_close_connection(cli2);
1728
1729         printf("finished locktest4\n");
1730         return correct;
1731 }
1732
1733 /*
1734   looks at lock upgrade/downgrade.
1735 */
1736 static BOOL run_locktest5(int dummy)
1737 {
1738         static struct cli_state *cli1, *cli2;
1739         const char *fname = "\\lockt5.lck";
1740         int fnum1, fnum2, fnum3;
1741         BOOL ret;
1742         char buf[1000];
1743         BOOL correct = True;
1744
1745         if (!torture_open_connection(&cli1, 0) || !torture_open_connection(&cli2, 1)) {
1746                 return False;
1747         }
1748
1749         cli_sockopt(cli1, sockops);
1750         cli_sockopt(cli2, sockops);
1751
1752         printf("starting locktest5\n");
1753
1754         cli_unlink(cli1, fname);
1755
1756         fnum1 = cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
1757         fnum2 = cli_open(cli2, fname, O_RDWR, DENY_NONE);
1758         fnum3 = cli_open(cli1, fname, O_RDWR, DENY_NONE);
1759
1760         memset(buf, 0, sizeof(buf));
1761
1762         if (cli_write(cli1, fnum1, 0, buf, 0, sizeof(buf)) != sizeof(buf)) {
1763                 printf("Failed to create file\n");
1764                 correct = False;
1765                 goto fail;
1766         }
1767
1768         /* Check for NT bug... */
1769         ret = cli_lock(cli1, fnum1, 0, 8, 0, READ_LOCK) &&
1770                   cli_lock(cli1, fnum3, 0, 1, 0, READ_LOCK);
1771         cli_close(cli1, fnum1);
1772         fnum1 = cli_open(cli1, fname, O_RDWR, DENY_NONE);
1773         ret = cli_lock(cli1, fnum1, 7, 1, 0, WRITE_LOCK);
1774         EXPECTED(ret, True);
1775         printf("this server %s the NT locking bug\n", ret ? "doesn't have" : "has");
1776         cli_close(cli1, fnum1);
1777         fnum1 = cli_open(cli1, fname, O_RDWR, DENY_NONE);
1778         cli_unlock(cli1, fnum3, 0, 1);
1779
1780         ret = cli_lock(cli1, fnum1, 0, 4, 0, WRITE_LOCK) &&
1781               cli_lock(cli1, fnum1, 1, 1, 0, READ_LOCK);
1782         EXPECTED(ret, True);
1783         printf("the same process %s overlay a write with a read lock\n", ret?"can":"cannot");
1784
1785         ret = cli_lock(cli2, fnum2, 0, 4, 0, READ_LOCK);
1786         EXPECTED(ret, False);
1787
1788         printf("a different processs %s get a read lock on the first process lock stack\n", ret?"can":"cannot");
1789
1790         /* Unlock the process 2 lock. */
1791         cli_unlock(cli2, fnum2, 0, 4);
1792
1793         ret = cli_lock(cli1, fnum3, 0, 4, 0, READ_LOCK);
1794         EXPECTED(ret, False);
1795
1796         printf("the same processs on a different fnum %s get a read lock\n", ret?"can":"cannot");
1797
1798         /* Unlock the process 1 fnum3 lock. */
1799         cli_unlock(cli1, fnum3, 0, 4);
1800
1801         /* Stack 2 more locks here. */
1802         ret = cli_lock(cli1, fnum1, 0, 4, 0, READ_LOCK) &&
1803                   cli_lock(cli1, fnum1, 0, 4, 0, READ_LOCK);
1804
1805         EXPECTED(ret, True);
1806         printf("the same process %s stack read locks\n", ret?"can":"cannot");
1807
1808         /* Unlock the first process lock, then check this was the WRITE lock that was
1809                 removed. */
1810
1811         ret = cli_unlock(cli1, fnum1, 0, 4) &&
1812                         cli_lock(cli2, fnum2, 0, 4, 0, READ_LOCK);
1813
1814         EXPECTED(ret, True);
1815         printf("the first unlock removes the %s lock\n", ret?"WRITE":"READ");
1816
1817         /* Unlock the process 2 lock. */
1818         cli_unlock(cli2, fnum2, 0, 4);
1819
1820         /* We should have 3 stacked locks here. Ensure we need to do 3 unlocks. */
1821
1822         ret = cli_unlock(cli1, fnum1, 1, 1) &&
1823                   cli_unlock(cli1, fnum1, 0, 4) &&
1824                   cli_unlock(cli1, fnum1, 0, 4);
1825
1826         EXPECTED(ret, True);
1827         printf("the same process %s unlock the stack of 4 locks\n", ret?"can":"cannot");
1828
1829         /* Ensure the next unlock fails. */
1830         ret = cli_unlock(cli1, fnum1, 0, 4);
1831         EXPECTED(ret, False);
1832         printf("the same process %s count the lock stack\n", !ret?"can":"cannot");
1833
1834         /* Ensure connection 2 can get a write lock. */
1835         ret = cli_lock(cli2, fnum2, 0, 4, 0, WRITE_LOCK);
1836         EXPECTED(ret, True);
1837
1838         printf("a different processs %s get a write lock on the unlocked stack\n", ret?"can":"cannot");
1839
1840
1841  fail:
1842         cli_close(cli1, fnum1);
1843         cli_close(cli2, fnum2);
1844         cli_unlink(cli1, fname);
1845         if (!torture_close_connection(cli1)) {
1846                 correct = False;
1847         }
1848         if (!torture_close_connection(cli2)) {
1849                 correct = False;
1850         }
1851
1852         printf("finished locktest5\n");
1853
1854         return correct;
1855 }
1856
1857 /*
1858   tries the unusual lockingX locktype bits
1859 */
1860 static BOOL run_locktest6(int dummy)
1861 {
1862         static struct cli_state *cli;
1863         const char *fname[1] = { "\\lock6.txt" };
1864         int i;
1865         int fnum;
1866         NTSTATUS status;
1867
1868         if (!torture_open_connection(&cli, 0)) {
1869                 return False;
1870         }
1871
1872         cli_sockopt(cli, sockops);
1873
1874         printf("starting locktest6\n");
1875
1876         for (i=0;i<1;i++) {
1877                 printf("Testing %s\n", fname[i]);
1878
1879                 cli_unlink(cli, fname[i]);
1880
1881                 fnum = cli_open(cli, fname[i], O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
1882                 status = cli_locktype(cli, fnum, 0, 8, 0, LOCKING_ANDX_CHANGE_LOCKTYPE);
1883                 cli_close(cli, fnum);
1884                 printf("CHANGE_LOCKTYPE gave %s\n", nt_errstr(status));
1885
1886                 fnum = cli_open(cli, fname[i], O_RDWR, DENY_NONE);
1887                 status = cli_locktype(cli, fnum, 0, 8, 0, LOCKING_ANDX_CANCEL_LOCK);
1888                 cli_close(cli, fnum);
1889                 printf("CANCEL_LOCK gave %s\n", nt_errstr(status));
1890
1891                 cli_unlink(cli, fname[i]);
1892         }
1893
1894         torture_close_connection(cli);
1895
1896         printf("finished locktest6\n");
1897         return True;
1898 }
1899
1900 static BOOL run_locktest7(int dummy)
1901 {
1902         struct cli_state *cli1;
1903         const char *fname = "\\lockt7.lck";
1904         int fnum1;
1905         char buf[200];
1906         BOOL correct = False;
1907
1908         if (!torture_open_connection(&cli1, 0)) {
1909                 return False;
1910         }
1911
1912         cli_sockopt(cli1, sockops);
1913
1914         printf("starting locktest7\n");
1915
1916         cli_unlink(cli1, fname);
1917
1918         fnum1 = cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
1919
1920         memset(buf, 0, sizeof(buf));
1921
1922         if (cli_write(cli1, fnum1, 0, buf, 0, sizeof(buf)) != sizeof(buf)) {
1923                 printf("Failed to create file\n");
1924                 goto fail;
1925         }
1926
1927         cli_setpid(cli1, 1);
1928
1929         if (!cli_lock(cli1, fnum1, 130, 4, 0, READ_LOCK)) {
1930                 printf("Unable to apply read lock on range 130:4, error was %s\n", cli_errstr(cli1));
1931                 goto fail;
1932         } else {
1933                 printf("pid1 successfully locked range 130:4 for READ\n");
1934         }
1935
1936         if (cli_read(cli1, fnum1, buf, 130, 4) != 4) {
1937                 printf("pid1 unable to read the range 130:4, error was %s\n", cli_errstr(cli1));
1938                 goto fail;
1939         } else {
1940                 printf("pid1 successfully read the range 130:4\n");
1941         }
1942
1943         if (cli_write(cli1, fnum1, 0, buf, 130, 4) != 4) {
1944                 printf("pid1 unable to write to the range 130:4, error was %s\n", cli_errstr(cli1));
1945                 if (NT_STATUS_V(cli_nt_error(cli1)) != NT_STATUS_V(NT_STATUS_FILE_LOCK_CONFLICT)) {
1946                         printf("Incorrect error (should be NT_STATUS_FILE_LOCK_CONFLICT)\n");
1947                         goto fail;
1948                 }
1949         } else {
1950                 printf("pid1 successfully wrote to the range 130:4 (should be denied)\n");
1951                 goto fail;
1952         }
1953
1954         cli_setpid(cli1, 2);
1955
1956         if (cli_read(cli1, fnum1, buf, 130, 4) != 4) {
1957                 printf("pid2 unable to read the range 130:4, error was %s\n", cli_errstr(cli1));
1958         } else {
1959                 printf("pid2 successfully read the range 130:4\n");
1960         }
1961
1962         if (cli_write(cli1, fnum1, 0, buf, 130, 4) != 4) {
1963                 printf("pid2 unable to write to the range 130:4, error was %s\n", cli_errstr(cli1));
1964                 if (NT_STATUS_V(cli_nt_error(cli1)) != NT_STATUS_V(NT_STATUS_FILE_LOCK_CONFLICT)) {
1965                         printf("Incorrect error (should be NT_STATUS_FILE_LOCK_CONFLICT)\n");
1966                         goto fail;
1967                 }
1968         } else {
1969                 printf("pid2 successfully wrote to the range 130:4 (should be denied)\n");
1970                 goto fail;
1971         }
1972
1973         cli_setpid(cli1, 1);
1974         cli_unlock(cli1, fnum1, 130, 4);
1975
1976         if (!cli_lock(cli1, fnum1, 130, 4, 0, WRITE_LOCK)) {
1977                 printf("Unable to apply write lock on range 130:4, error was %s\n", cli_errstr(cli1));
1978                 goto fail;
1979         } else {
1980                 printf("pid1 successfully locked range 130:4 for WRITE\n");
1981         }
1982
1983         if (cli_read(cli1, fnum1, buf, 130, 4) != 4) {
1984                 printf("pid1 unable to read the range 130:4, error was %s\n", cli_errstr(cli1));
1985                 goto fail;
1986         } else {
1987                 printf("pid1 successfully read the range 130:4\n");
1988         }
1989
1990         if (cli_write(cli1, fnum1, 0, buf, 130, 4) != 4) {
1991                 printf("pid1 unable to write to the range 130:4, error was %s\n", cli_errstr(cli1));
1992                 goto fail;
1993         } else {
1994                 printf("pid1 successfully wrote to the range 130:4\n");
1995         }
1996
1997         cli_setpid(cli1, 2);
1998
1999         if (cli_read(cli1, fnum1, buf, 130, 4) != 4) {
2000                 printf("pid2 unable to read the range 130:4, error was %s\n", cli_errstr(cli1));
2001                 if (NT_STATUS_V(cli_nt_error(cli1)) != NT_STATUS_V(NT_STATUS_FILE_LOCK_CONFLICT)) {
2002                         printf("Incorrect error (should be NT_STATUS_FILE_LOCK_CONFLICT)\n");
2003                         goto fail;
2004                 }
2005         } else {
2006                 printf("pid2 successfully read the range 130:4 (should be denied)\n");
2007                 goto fail;
2008         }
2009
2010         if (cli_write(cli1, fnum1, 0, buf, 130, 4) != 4) {
2011                 printf("pid2 unable to write to the range 130:4, error was %s\n", cli_errstr(cli1));
2012                 if (NT_STATUS_V(cli_nt_error(cli1)) != NT_STATUS_V(NT_STATUS_FILE_LOCK_CONFLICT)) {
2013                         printf("Incorrect error (should be NT_STATUS_FILE_LOCK_CONFLICT)\n");
2014                         goto fail;
2015                 }
2016         } else {
2017                 printf("pid2 successfully wrote to the range 130:4 (should be denied)\n");
2018                 goto fail;
2019         }
2020
2021         cli_unlock(cli1, fnum1, 130, 0);
2022         correct = True;
2023
2024 fail:
2025         cli_close(cli1, fnum1);
2026         cli_unlink(cli1, fname);
2027         torture_close_connection(cli1);
2028
2029         printf("finished locktest7\n");
2030         return correct;
2031 }
2032
2033 /*
2034 test whether fnums and tids open on one VC are available on another (a major
2035 security hole)
2036 */
2037 static BOOL run_fdpasstest(int dummy)
2038 {
2039         struct cli_state *cli1, *cli2;
2040         const char *fname = "\\fdpass.tst";
2041         int fnum1;
2042         pstring buf;
2043
2044         if (!torture_open_connection(&cli1, 0) || !torture_open_connection(&cli2, 1)) {
2045                 return False;
2046         }
2047         cli_sockopt(cli1, sockops);
2048         cli_sockopt(cli2, sockops);
2049
2050         printf("starting fdpasstest\n");
2051
2052         cli_unlink(cli1, fname);
2053
2054         fnum1 = cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
2055         if (fnum1 == -1) {
2056                 printf("open of %s failed (%s)\n", fname, cli_errstr(cli1));
2057                 return False;
2058         }
2059
2060         if (cli_write(cli1, fnum1, 0, "hello world\n", 0, 13) != 13) {
2061                 printf("write failed (%s)\n", cli_errstr(cli1));
2062                 return False;
2063         }
2064
2065         cli2->vuid = cli1->vuid;
2066         cli2->cnum = cli1->cnum;
2067         cli2->pid = cli1->pid;
2068
2069         if (cli_read(cli2, fnum1, buf, 0, 13) == 13) {
2070                 printf("read succeeded! nasty security hole [%s]\n",
2071                        buf);
2072                 return False;
2073         }
2074
2075         cli_close(cli1, fnum1);
2076         cli_unlink(cli1, fname);
2077
2078         torture_close_connection(cli1);
2079         torture_close_connection(cli2);
2080
2081         printf("finished fdpasstest\n");
2082         return True;
2083 }
2084
2085 static BOOL run_fdsesstest(int dummy)
2086 {
2087         struct cli_state *cli;
2088         uint16 new_vuid;
2089         uint16 saved_vuid;
2090         uint16 new_cnum;
2091         uint16 saved_cnum;
2092         const char *fname = "\\fdsess.tst";
2093         const char *fname1 = "\\fdsess1.tst";
2094         int fnum1;
2095         int fnum2;
2096         pstring buf;
2097         BOOL ret = True;
2098
2099         if (!torture_open_connection(&cli, 0))
2100                 return False;
2101         cli_sockopt(cli, sockops);
2102
2103         if (!torture_cli_session_setup2(cli, &new_vuid))
2104                 return False;
2105
2106         saved_cnum = cli->cnum;
2107         if (!cli_send_tconX(cli, share, "?????", "", 1))
2108                 return False;
2109         new_cnum = cli->cnum;
2110         cli->cnum = saved_cnum;
2111
2112         printf("starting fdsesstest\n");
2113
2114         cli_unlink(cli, fname);
2115         cli_unlink(cli, fname1);
2116
2117         fnum1 = cli_open(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
2118         if (fnum1 == -1) {
2119                 printf("open of %s failed (%s)\n", fname, cli_errstr(cli));
2120                 return False;
2121         }
2122
2123         if (cli_write(cli, fnum1, 0, "hello world\n", 0, 13) != 13) {
2124                 printf("write failed (%s)\n", cli_errstr(cli));
2125                 return False;
2126         }
2127
2128         saved_vuid = cli->vuid;
2129         cli->vuid = new_vuid;
2130
2131         if (cli_read(cli, fnum1, buf, 0, 13) == 13) {
2132                 printf("read succeeded with different vuid! nasty security hole [%s]\n",
2133                        buf);
2134                 ret = False;
2135         }
2136         /* Try to open a file with different vuid, samba cnum. */
2137         fnum2 = cli_open(cli, fname1, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
2138         if (fnum2 != -1) {
2139                 printf("create with different vuid, same cnum succeeded.\n");
2140                 cli_close(cli, fnum2);
2141                 cli_unlink(cli, fname1);
2142         } else {
2143                 printf("create with different vuid, same cnum failed.\n");
2144                 printf("This will cause problems with service clients.\n");
2145                 ret = False;
2146         }
2147
2148         cli->vuid = saved_vuid;
2149
2150         /* Try with same vuid, different cnum. */
2151         cli->cnum = new_cnum;
2152
2153         if (cli_read(cli, fnum1, buf, 0, 13) == 13) {
2154                 printf("read succeeded with different cnum![%s]\n",
2155                        buf);
2156                 ret = False;
2157         }
2158
2159         cli->cnum = saved_cnum;
2160         cli_close(cli, fnum1);
2161         cli_unlink(cli, fname);
2162
2163         torture_close_connection(cli);
2164
2165         printf("finished fdsesstest\n");
2166         return ret;
2167 }
2168
2169 /*
2170   This test checks that
2171
2172   1) the server does not allow an unlink on a file that is open
2173 */
2174 static BOOL run_unlinktest(int dummy)
2175 {
2176         struct cli_state *cli;
2177         const char *fname = "\\unlink.tst";
2178         int fnum;
2179         BOOL correct = True;
2180
2181         if (!torture_open_connection(&cli, 0)) {
2182                 return False;
2183         }
2184
2185         cli_sockopt(cli, sockops);
2186
2187         printf("starting unlink test\n");
2188
2189         cli_unlink(cli, fname);
2190
2191         cli_setpid(cli, 1);
2192
2193         fnum = cli_open(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
2194         if (fnum == -1) {
2195                 printf("open of %s failed (%s)\n", fname, cli_errstr(cli));
2196                 return False;
2197         }
2198
2199         if (cli_unlink(cli, fname)) {
2200                 printf("error: server allowed unlink on an open file\n");
2201                 correct = False;
2202         } else {
2203                 correct = check_error(__LINE__, cli, ERRDOS, ERRbadshare,
2204                                       NT_STATUS_SHARING_VIOLATION);
2205         }
2206
2207         cli_close(cli, fnum);
2208         cli_unlink(cli, fname);
2209
2210         if (!torture_close_connection(cli)) {
2211                 correct = False;
2212         }
2213
2214         printf("unlink test finished\n");
2215
2216         return correct;
2217 }
2218
2219
2220 /*
2221 test how many open files this server supports on the one socket
2222 */
2223 static BOOL run_maxfidtest(int dummy)
2224 {
2225         struct cli_state *cli;
2226         const char *ftemplate = "\\maxfid.%d.%d";
2227         fstring fname;
2228         int fnums[0x11000], i;
2229         int retries=4;
2230         BOOL correct = True;
2231
2232         cli = current_cli;
2233
2234         if (retries <= 0) {
2235                 printf("failed to connect\n");
2236                 return False;
2237         }
2238
2239         cli_sockopt(cli, sockops);
2240
2241         for (i=0; i<0x11000; i++) {
2242                 slprintf(fname,sizeof(fname)-1,ftemplate, i,(int)getpid());
2243                 if ((fnums[i] = cli_open(cli, fname,
2244                                         O_RDWR|O_CREAT|O_TRUNC, DENY_NONE)) ==
2245                     -1) {
2246                         printf("open of %s failed (%s)\n",
2247                                fname, cli_errstr(cli));
2248                         printf("maximum fnum is %d\n", i);
2249                         break;
2250                 }
2251                 printf("%6d\r", i);
2252         }
2253         printf("%6d\n", i);
2254         i--;
2255
2256         printf("cleaning up\n");
2257         for (;i>=0;i--) {
2258                 slprintf(fname,sizeof(fname)-1,ftemplate, i,(int)getpid());
2259                 cli_close(cli, fnums[i]);
2260                 if (!cli_unlink(cli, fname)) {
2261                         printf("unlink of %s failed (%s)\n",
2262                                fname, cli_errstr(cli));
2263                         correct = False;
2264                 }
2265                 printf("%6d\r", i);
2266         }
2267         printf("%6d\n", 0);
2268
2269         printf("maxfid test finished\n");
2270         if (!torture_close_connection(cli)) {
2271                 correct = False;
2272         }
2273         return correct;
2274 }
2275
2276 /* generate a random buffer */
2277 static void rand_buf(char *buf, int len)
2278 {
2279         while (len--) {
2280                 *buf = (char)sys_random();
2281                 buf++;
2282         }
2283 }
2284
2285 /* send smb negprot commands, not reading the response */
2286 static BOOL run_negprot_nowait(int dummy)
2287 {
2288         int i;
2289         static struct cli_state *cli;
2290         BOOL correct = True;
2291
2292         printf("starting negprot nowait test\n");
2293
2294         if (!(cli = open_nbt_connection())) {
2295                 return False;
2296         }
2297
2298         for (i=0;i<50000;i++) {
2299                 cli_negprot_send(cli);
2300         }
2301
2302         if (!torture_close_connection(cli)) {
2303                 correct = False;
2304         }
2305
2306         printf("finished negprot nowait test\n");
2307
2308         return correct;
2309 }
2310
2311
2312 /* send random IPC commands */
2313 static BOOL run_randomipc(int dummy)
2314 {
2315         char *rparam = NULL;
2316         char *rdata = NULL;
2317         unsigned int rdrcnt,rprcnt;
2318         pstring param;
2319         int api, param_len, i;
2320         struct cli_state *cli;
2321         BOOL correct = True;
2322         int count = 50000;
2323
2324         printf("starting random ipc test\n");
2325
2326         if (!torture_open_connection(&cli, 0)) {
2327                 return False;
2328         }
2329
2330         for (i=0;i<count;i++) {
2331                 api = sys_random() % 500;
2332                 param_len = (sys_random() % 64);
2333
2334                 rand_buf(param, param_len);
2335
2336                 SSVAL(param,0,api);
2337
2338                 cli_api(cli,
2339                         param, param_len, 8,
2340                         NULL, 0, BUFFER_SIZE,
2341                         &rparam, &rprcnt,
2342                         &rdata, &rdrcnt);
2343                 if (i % 100 == 0) {
2344                         printf("%d/%d\r", i,count);
2345                 }
2346         }
2347         printf("%d/%d\n", i, count);
2348
2349         if (!torture_close_connection(cli)) {
2350                 correct = False;
2351         }
2352
2353         printf("finished random ipc test\n");
2354
2355         return correct;
2356 }
2357
2358
2359
2360 static void browse_callback(const char *sname, uint32 stype,
2361                             const char *comment, void *state)
2362 {
2363         printf("\t%20.20s %08x %s\n", sname, stype, comment);
2364 }
2365
2366
2367
2368 /*
2369   This test checks the browse list code
2370
2371 */
2372 static BOOL run_browsetest(int dummy)
2373 {
2374         static struct cli_state *cli;
2375         BOOL correct = True;
2376
2377         printf("starting browse test\n");
2378
2379         if (!torture_open_connection(&cli, 0)) {
2380                 return False;
2381         }
2382
2383         printf("domain list:\n");
2384         cli_NetServerEnum(cli, cli->server_domain,
2385                           SV_TYPE_DOMAIN_ENUM,
2386                           browse_callback, NULL);
2387
2388         printf("machine list:\n");
2389         cli_NetServerEnum(cli, cli->server_domain,
2390                           SV_TYPE_ALL,
2391                           browse_callback, NULL);
2392
2393         if (!torture_close_connection(cli)) {
2394                 correct = False;
2395         }
2396
2397         printf("browse test finished\n");
2398
2399         return correct;
2400
2401 }
2402
2403
2404 /*
2405   This checks how the getatr calls works
2406 */
2407 static BOOL run_attrtest(int dummy)
2408 {
2409         struct cli_state *cli;
2410         int fnum;
2411         time_t t, t2;
2412         const char *fname = "\\attrib123456789.tst";
2413         BOOL correct = True;
2414
2415         printf("starting attrib test\n");
2416
2417         if (!torture_open_connection(&cli, 0)) {
2418                 return False;
2419         }
2420
2421         cli_unlink(cli, fname);
2422         fnum = cli_open(cli, fname,
2423                         O_RDWR | O_CREAT | O_TRUNC, DENY_NONE);
2424         cli_close(cli, fnum);
2425         if (!cli_getatr(cli, fname, NULL, NULL, &t)) {
2426                 printf("getatr failed (%s)\n", cli_errstr(cli));
2427                 correct = False;
2428         }
2429
2430         if (abs(t - time(NULL)) > 60*60*24*10) {
2431                 printf("ERROR: SMBgetatr bug. time is %s",
2432                        ctime(&t));
2433                 t = time(NULL);
2434                 correct = True;
2435         }
2436
2437         t2 = t-60*60*24; /* 1 day ago */
2438
2439         if (!cli_setatr(cli, fname, 0, t2)) {
2440                 printf("setatr failed (%s)\n", cli_errstr(cli));
2441                 correct = True;
2442         }
2443
2444         if (!cli_getatr(cli, fname, NULL, NULL, &t)) {
2445                 printf("getatr failed (%s)\n", cli_errstr(cli));
2446                 correct = True;
2447         }
2448
2449         if (t != t2) {
2450                 printf("ERROR: getatr/setatr bug. times are\n%s",
2451                        ctime(&t));
2452                 printf("%s", ctime(&t2));
2453                 correct = True;
2454         }
2455
2456         cli_unlink(cli, fname);
2457
2458         if (!torture_close_connection(cli)) {
2459                 correct = False;
2460         }
2461
2462         printf("attrib test finished\n");
2463
2464         return correct;
2465 }
2466
2467
2468 /*
2469   This checks a couple of trans2 calls
2470 */
2471 static BOOL run_trans2test(int dummy)
2472 {
2473         struct cli_state *cli;
2474         int fnum;
2475         SMB_OFF_T size;
2476         time_t c_time, a_time, m_time;
2477         struct timespec c_time_ts, a_time_ts, m_time_ts, w_time_ts, m_time2_ts;
2478         const char *fname = "\\trans2.tst";
2479         const char *dname = "\\trans2";
2480         const char *fname2 = "\\trans2\\trans2.tst";
2481         pstring pname;
2482         BOOL correct = True;
2483
2484         printf("starting trans2 test\n");
2485
2486         if (!torture_open_connection(&cli, 0)) {
2487                 return False;
2488         }
2489
2490         cli_unlink(cli, fname);
2491         fnum = cli_open(cli, fname,
2492                         O_RDWR | O_CREAT | O_TRUNC, DENY_NONE);
2493         if (!cli_qfileinfo(cli, fnum, NULL, &size, &c_time_ts, &a_time_ts, &w_time_ts,
2494                            &m_time_ts, NULL)) {
2495                 printf("ERROR: qfileinfo failed (%s)\n", cli_errstr(cli));
2496                 correct = False;
2497         }
2498
2499         if (!cli_qfilename(cli, fnum, pname)) {
2500                 printf("ERROR: qfilename failed (%s)\n", cli_errstr(cli));
2501                 correct = False;
2502         }
2503
2504         if (strcmp(pname, fname)) {
2505                 printf("qfilename gave different name? [%s] [%s]\n",
2506                        fname, pname);
2507                 correct = False;
2508         }
2509
2510         cli_close(cli, fnum);
2511
2512         sleep(2);
2513
2514         cli_unlink(cli, fname);
2515         fnum = cli_open(cli, fname,
2516                         O_RDWR | O_CREAT | O_TRUNC, DENY_NONE);
2517         if (fnum == -1) {
2518                 printf("open of %s failed (%s)\n", fname, cli_errstr(cli));
2519                 return False;
2520         }
2521         cli_close(cli, fnum);
2522
2523         if (!cli_qpathinfo(cli, fname, &c_time, &a_time, &m_time, &size, NULL)) {
2524                 printf("ERROR: qpathinfo failed (%s)\n", cli_errstr(cli));
2525                 correct = False;
2526         } else {
2527                 if (c_time != m_time) {
2528                         printf("create time=%s", ctime(&c_time));
2529                         printf("modify time=%s", ctime(&m_time));
2530                         printf("This system appears to have sticky create times\n");
2531                 }
2532                 if (a_time % (60*60) == 0) {
2533                         printf("access time=%s", ctime(&a_time));
2534                         printf("This system appears to set a midnight access time\n");
2535                         correct = False;
2536                 }
2537
2538                 if (abs(m_time - time(NULL)) > 60*60*24*7) {
2539                         printf("ERROR: totally incorrect times - maybe word reversed? mtime=%s", ctime(&m_time));
2540                         correct = False;
2541                 }
2542         }
2543
2544
2545         cli_unlink(cli, fname);
2546         fnum = cli_open(cli, fname,
2547                         O_RDWR | O_CREAT | O_TRUNC, DENY_NONE);
2548         cli_close(cli, fnum);
2549         if (!cli_qpathinfo2(cli, fname, &c_time_ts, &a_time_ts, &w_time_ts,
2550                             &m_time_ts, &size, NULL, NULL)) {
2551                 printf("ERROR: qpathinfo2 failed (%s)\n", cli_errstr(cli));
2552                 correct = False;
2553         } else {
2554                 if (w_time_ts.tv_sec < 60*60*24*2) {
2555                         printf("write time=%s", ctime(&w_time_ts.tv_sec));
2556                         printf("This system appears to set a initial 0 write time\n");
2557                         correct = False;
2558                 }
2559         }
2560
2561         cli_unlink(cli, fname);
2562
2563
2564         /* check if the server updates the directory modification time
2565            when creating a new file */
2566         if (!cli_mkdir(cli, dname)) {
2567                 printf("ERROR: mkdir failed (%s)\n", cli_errstr(cli));
2568                 correct = False;
2569         }
2570         sleep(3);
2571         if (!cli_qpathinfo2(cli, "\\trans2\\", &c_time_ts, &a_time_ts, &w_time_ts,
2572                             &m_time_ts, &size, NULL, NULL)) {
2573                 printf("ERROR: qpathinfo2 failed (%s)\n", cli_errstr(cli));
2574                 correct = False;
2575         }
2576
2577         fnum = cli_open(cli, fname2,
2578                         O_RDWR | O_CREAT | O_TRUNC, DENY_NONE);
2579         cli_write(cli, fnum,  0, (char *)&fnum, 0, sizeof(fnum));
2580         cli_close(cli, fnum);
2581         if (!cli_qpathinfo2(cli, "\\trans2\\", &c_time_ts, &a_time_ts, &w_time_ts,
2582                             &m_time2_ts, &size, NULL, NULL)) {
2583                 printf("ERROR: qpathinfo2 failed (%s)\n", cli_errstr(cli));
2584                 correct = False;
2585         } else {
2586                 if (memcmp(&m_time_ts, &m_time2_ts, sizeof(struct timespec))
2587                     == 0) {
2588                         printf("This system does not update directory modification times\n");
2589                         correct = False;
2590                 }
2591         }
2592         cli_unlink(cli, fname2);
2593         cli_rmdir(cli, dname);
2594
2595         if (!torture_close_connection(cli)) {
2596                 correct = False;
2597         }
2598
2599         printf("trans2 test finished\n");
2600
2601         return correct;
2602 }
2603
2604 /*
2605   This checks new W2K calls.
2606 */
2607
2608 static BOOL new_trans(struct cli_state *pcli, int fnum, int level)
2609 {
2610         char *buf = NULL;
2611         uint32 len;
2612         BOOL correct = True;
2613
2614         if (!cli_qfileinfo_test(pcli, fnum, level, &buf, &len)) {
2615                 printf("ERROR: qfileinfo (%d) failed (%s)\n", level, cli_errstr(pcli));
2616                 correct = False;
2617         } else {
2618                 printf("qfileinfo: level %d, len = %u\n", level, len);
2619                 dump_data(0, buf, len);
2620                 printf("\n");
2621         }
2622         SAFE_FREE(buf);
2623         return correct;
2624 }
2625
2626 static BOOL run_w2ktest(int dummy)
2627 {
2628         struct cli_state *cli;
2629         int fnum;
2630         const char *fname = "\\w2ktest\\w2k.tst";
2631         int level;
2632         BOOL correct = True;
2633
2634         printf("starting w2k test\n");
2635
2636         if (!torture_open_connection(&cli, 0)) {
2637                 return False;
2638         }
2639
2640         fnum = cli_open(cli, fname,
2641                         O_RDWR | O_CREAT , DENY_NONE);
2642
2643         for (level = 1004; level < 1040; level++) {
2644                 new_trans(cli, fnum, level);
2645         }
2646
2647         cli_close(cli, fnum);
2648
2649         if (!torture_close_connection(cli)) {
2650                 correct = False;
2651         }
2652
2653         printf("w2k test finished\n");
2654
2655         return correct;
2656 }
2657
2658
2659 /*
2660   this is a harness for some oplock tests
2661  */
2662 static BOOL run_oplock1(int dummy)
2663 {
2664         struct cli_state *cli1;
2665         const char *fname = "\\lockt1.lck";
2666         int fnum1;
2667         BOOL correct = True;
2668
2669         printf("starting oplock test 1\n");
2670
2671         if (!torture_open_connection(&cli1, 0)) {
2672                 return False;
2673         }
2674
2675         cli_unlink(cli1, fname);
2676
2677         cli_sockopt(cli1, sockops);
2678
2679         cli1->use_oplocks = True;
2680
2681         fnum1 = cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
2682         if (fnum1 == -1) {
2683                 printf("open of %s failed (%s)\n", fname, cli_errstr(cli1));
2684                 return False;
2685         }
2686
2687         cli1->use_oplocks = False;
2688
2689         cli_unlink(cli1, fname);
2690         cli_unlink(cli1, fname);
2691
2692         if (!cli_close(cli1, fnum1)) {
2693                 printf("close2 failed (%s)\n", cli_errstr(cli1));
2694                 return False;
2695         }
2696
2697         if (!cli_unlink(cli1, fname)) {
2698                 printf("unlink failed (%s)\n", cli_errstr(cli1));
2699                 return False;
2700         }
2701
2702         if (!torture_close_connection(cli1)) {
2703                 correct = False;
2704         }
2705
2706         printf("finished oplock test 1\n");
2707
2708         return correct;
2709 }
2710
2711 static BOOL run_oplock2(int dummy)
2712 {
2713         struct cli_state *cli1, *cli2;
2714         const char *fname = "\\lockt2.lck";
2715         int fnum1, fnum2;
2716         int saved_use_oplocks = use_oplocks;
2717         char buf[4];
2718         BOOL correct = True;
2719         volatile BOOL *shared_correct;
2720
2721         shared_correct = (volatile BOOL *)shm_setup(sizeof(BOOL));
2722         *shared_correct = True;
2723
2724         use_level_II_oplocks = True;
2725         use_oplocks = True;
2726
2727         printf("starting oplock test 2\n");
2728
2729         if (!torture_open_connection(&cli1, 0)) {
2730                 use_level_II_oplocks = False;
2731                 use_oplocks = saved_use_oplocks;
2732                 return False;
2733         }
2734
2735         cli1->use_oplocks = True;
2736         cli1->use_level_II_oplocks = True;
2737
2738         if (!torture_open_connection(&cli2, 1)) {
2739                 use_level_II_oplocks = False;
2740                 use_oplocks = saved_use_oplocks;
2741                 return False;
2742         }
2743
2744         cli2->use_oplocks = True;
2745         cli2->use_level_II_oplocks = True;
2746
2747         cli_unlink(cli1, fname);
2748
2749         cli_sockopt(cli1, sockops);
2750         cli_sockopt(cli2, sockops);
2751
2752         fnum1 = cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
2753         if (fnum1 == -1) {
2754                 printf("open of %s failed (%s)\n", fname, cli_errstr(cli1));
2755                 return False;
2756         }
2757
2758         /* Don't need the globals any more. */
2759         use_level_II_oplocks = False;
2760         use_oplocks = saved_use_oplocks;
2761
2762         if (fork() == 0) {
2763                 /* Child code */
2764                 fnum2 = cli_open(cli2, fname, O_RDWR, DENY_NONE);
2765                 if (fnum2 == -1) {
2766                         printf("second open of %s failed (%s)\n", fname, cli_errstr(cli1));
2767                         *shared_correct = False;
2768                         exit(0);
2769                 }
2770
2771                 sleep(2);
2772
2773                 if (!cli_close(cli2, fnum2)) {
2774                         printf("close2 failed (%s)\n", cli_errstr(cli1));
2775                         *shared_correct = False;
2776                 }
2777
2778                 exit(0);
2779         }
2780
2781         sleep(2);
2782
2783         /* Ensure cli1 processes the break. Empty file should always return 0
2784          * bytes.  */
2785
2786         if (cli_read(cli1, fnum1, buf, 0, 4) != 0) {
2787                 printf("read on fnum1 failed (%s)\n", cli_errstr(cli1));
2788                 correct = False;
2789         }
2790
2791         /* Should now be at level II. */
2792         /* Test if sending a write locks causes a break to none. */
2793
2794         if (!cli_lock(cli1, fnum1, 0, 4, 0, READ_LOCK)) {
2795                 printf("lock failed (%s)\n", cli_errstr(cli1));
2796                 correct = False;
2797         }
2798
2799         cli_unlock(cli1, fnum1, 0, 4);
2800
2801         sleep(2);
2802
2803         if (!cli_lock(cli1, fnum1, 0, 4, 0, WRITE_LOCK)) {
2804                 printf("lock failed (%s)\n", cli_errstr(cli1));
2805                 correct = False;
2806         }
2807
2808         cli_unlock(cli1, fnum1, 0, 4);
2809
2810         sleep(2);
2811
2812         cli_read(cli1, fnum1, buf, 0, 4);
2813
2814 #if 0
2815         if (cli_write(cli1, fnum1, 0, buf, 0, 4) != 4) {
2816                 printf("write on fnum1 failed (%s)\n", cli_errstr(cli1));
2817                 correct = False;
2818         }
2819 #endif
2820
2821         if (!cli_close(cli1, fnum1)) {
2822                 printf("close1 failed (%s)\n", cli_errstr(cli1));
2823                 correct = False;
2824         }
2825
2826         sleep(4);
2827
2828         if (!cli_unlink(cli1, fname)) {
2829                 printf("unlink failed (%s)\n", cli_errstr(cli1));
2830                 correct = False;
2831         }
2832
2833         if (!torture_close_connection(cli1)) {
2834                 correct = False;
2835         }
2836
2837         if (!*shared_correct) {
2838                 correct = False;
2839         }
2840
2841         printf("finished oplock test 2\n");
2842
2843         return correct;
2844 }
2845
2846 /* handler for oplock 3 tests */
2847 static BOOL oplock3_handler(struct cli_state *cli, int fnum, unsigned char level)
2848 {
2849         printf("got oplock break fnum=%d level=%d\n",
2850                fnum, level);
2851         return cli_oplock_ack(cli, fnum, level);
2852 }
2853
2854 static BOOL run_oplock3(int dummy)
2855 {
2856         struct cli_state *cli;
2857         const char *fname = "\\oplockt3.dat";
2858         int fnum;
2859         char buf[4] = "abcd";
2860         BOOL correct = True;
2861         volatile BOOL *shared_correct;
2862
2863         shared_correct = (volatile BOOL *)shm_setup(sizeof(BOOL));
2864         *shared_correct = True;
2865
2866         printf("starting oplock test 3\n");
2867
2868         if (fork() == 0) {
2869                 /* Child code */
2870                 use_oplocks = True;
2871                 use_level_II_oplocks = True;
2872                 if (!torture_open_connection(&cli, 0)) {
2873                         *shared_correct = False;
2874                         exit(0);
2875                 }
2876                 sleep(2);
2877                 /* try to trigger a oplock break in parent */
2878                 fnum = cli_open(cli, fname, O_RDWR, DENY_NONE);
2879                 cli_write(cli, fnum, 0, buf, 0, 4);
2880                 exit(0);
2881         }
2882
2883         /* parent code */
2884         use_oplocks = True;
2885         use_level_II_oplocks = True;
2886         if (!torture_open_connection(&cli, 1)) { /* other is forked */
2887                 return False;
2888         }
2889         cli_oplock_handler(cli, oplock3_handler);
2890         fnum = cli_open(cli, fname, O_RDWR|O_CREAT, DENY_NONE);
2891         cli_write(cli, fnum, 0, buf, 0, 4);
2892         cli_close(cli, fnum);
2893         fnum = cli_open(cli, fname, O_RDWR, DENY_NONE);
2894         cli->timeout = 20000;
2895         cli_receive_smb(cli);
2896         printf("finished oplock test 3\n");
2897
2898         return (correct && *shared_correct);
2899
2900 /* What are we looking for here?  What's sucess and what's FAILURE? */
2901 }
2902
2903
2904
2905 /*
2906   Test delete on close semantics.
2907  */
2908 static BOOL run_deletetest(int dummy)
2909 {
2910         struct cli_state *cli1 = NULL;
2911         struct cli_state *cli2 = NULL;
2912         const char *fname = "\\delete.file";
2913         int fnum1 = -1;
2914         int fnum2 = -1;
2915         BOOL correct = True;
2916
2917         printf("starting delete test\n");
2918
2919         if (!torture_open_connection(&cli1, 0)) {
2920                 return False;
2921         }
2922
2923         cli_sockopt(cli1, sockops);
2924
2925         /* Test 1 - this should delete the file on close. */
2926
2927         cli_setatr(cli1, fname, 0, 0);
2928         cli_unlink(cli1, fname);
2929
2930         fnum1 = cli_nt_create_full(cli1, fname, 0, GENERIC_ALL_ACCESS|DELETE_ACCESS, FILE_ATTRIBUTE_NORMAL,
2931                                    0, FILE_OVERWRITE_IF,
2932                                    FILE_DELETE_ON_CLOSE, 0);
2933
2934         if (fnum1 == -1) {
2935                 printf("[1] open of %s failed (%s)\n", fname, cli_errstr(cli1));
2936                 correct = False;
2937                 goto fail;
2938         }
2939
2940 #if 0 /* JRATEST */
2941         {
2942                 uint32 *accinfo = NULL;
2943                 uint32 len;
2944                 cli_qfileinfo_test(cli1, fnum1, SMB_FILE_ACCESS_INFORMATION, (char **)&accinfo, &len);
2945                 if (accinfo)
2946                         printf("access mode = 0x%lx\n", *accinfo);
2947                 SAFE_FREE(accinfo);
2948         }
2949 #endif
2950
2951         if (!cli_close(cli1, fnum1)) {
2952                 printf("[1] close failed (%s)\n", cli_errstr(cli1));
2953                 correct = False;
2954                 goto fail;
2955         }
2956
2957         fnum1 = cli_open(cli1, fname, O_RDWR, DENY_NONE);
2958         if (fnum1 != -1) {
2959                 printf("[1] open of %s succeeded (should fail)\n", fname);
2960                 correct = False;
2961                 goto fail;
2962         }
2963
2964         printf("first delete on close test succeeded.\n");
2965
2966         /* Test 2 - this should delete the file on close. */
2967
2968         cli_setatr(cli1, fname, 0, 0);
2969         cli_unlink(cli1, fname);
2970
2971         fnum1 = cli_nt_create_full(cli1, fname, 0, GENERIC_ALL_ACCESS,
2972                                    FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE,
2973                                    FILE_OVERWRITE_IF, 0, 0);
2974
2975         if (fnum1 == -1) {
2976                 printf("[2] open of %s failed (%s)\n", fname, cli_errstr(cli1));
2977                 correct = False;
2978                 goto fail;
2979         }
2980
2981         if (!cli_nt_delete_on_close(cli1, fnum1, True)) {
2982                 printf("[2] setting delete_on_close failed (%s)\n", cli_errstr(cli1));
2983                 correct = False;
2984                 goto fail;
2985         }
2986
2987         if (!cli_close(cli1, fnum1)) {
2988                 printf("[2] close failed (%s)\n", cli_errstr(cli1));
2989                 correct = False;
2990                 goto fail;
2991         }
2992
2993         fnum1 = cli_open(cli1, fname, O_RDONLY, DENY_NONE);
2994         if (fnum1 != -1) {
2995                 printf("[2] open of %s succeeded should have been deleted on close !\n", fname);
2996                 if (!cli_close(cli1, fnum1)) {
2997                         printf("[2] close failed (%s)\n", cli_errstr(cli1));
2998                         correct = False;
2999                         goto fail;
3000                 }
3001                 cli_unlink(cli1, fname);
3002         } else
3003                 printf("second delete on close test succeeded.\n");
3004
3005         /* Test 3 - ... */
3006         cli_setatr(cli1, fname, 0, 0);
3007         cli_unlink(cli1, fname);
3008
3009         fnum1 = cli_nt_create_full(cli1, fname, 0, GENERIC_ALL_ACCESS, FILE_ATTRIBUTE_NORMAL,
3010                                    FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OVERWRITE_IF, 0, 0);
3011
3012         if (fnum1 == -1) {
3013                 printf("[3] open - 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
3014                 correct = False;
3015                 goto fail;
3016         }
3017
3018         /* This should fail with a sharing violation - open for delete is only compatible
3019            with SHARE_DELETE. */
3020
3021         fnum2 = cli_nt_create_full(cli1, fname, 0, GENERIC_READ_ACCESS, FILE_ATTRIBUTE_NORMAL,
3022                         FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OPEN, 0, 0);
3023
3024         if (fnum2 != -1) {
3025                 printf("[3] open  - 2 of %s succeeded - should have failed.\n", fname);
3026                 correct = False;
3027                 goto fail;
3028         }
3029
3030         /* This should succeed. */
3031
3032         fnum2 = cli_nt_create_full(cli1, fname, 0, GENERIC_READ_ACCESS, FILE_ATTRIBUTE_NORMAL,
3033                         FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, FILE_OPEN, 0, 0);
3034
3035         if (fnum2 == -1) {
3036                 printf("[3] open  - 2 of %s failed (%s)\n", fname, cli_errstr(cli1));
3037                 correct = False;
3038                 goto fail;
3039         }
3040
3041         if (!cli_nt_delete_on_close(cli1, fnum1, True)) {
3042                 printf("[3] setting delete_on_close failed (%s)\n", cli_errstr(cli1));
3043                 correct = False;
3044                 goto fail;
3045         }
3046
3047         if (!cli_close(cli1, fnum1)) {
3048                 printf("[3] close 1 failed (%s)\n", cli_errstr(cli1));
3049                 correct = False;
3050                 goto fail;
3051         }
3052
3053         if (!cli_close(cli1, fnum2)) {
3054                 printf("[3] close 2 failed (%s)\n", cli_errstr(cli1));
3055                 correct = False;
3056                 goto fail;
3057         }
3058
3059         /* This should fail - file should no longer be there. */
3060
3061         fnum1 = cli_open(cli1, fname, O_RDONLY, DENY_NONE);
3062         if (fnum1 != -1) {
3063                 printf("[3] open of %s succeeded should have been deleted on close !\n", fname);
3064                 if (!cli_close(cli1, fnum1)) {
3065                         printf("[3] close failed (%s)\n", cli_errstr(cli1));
3066                 }
3067                 cli_unlink(cli1, fname);
3068                 correct = False;
3069                 goto fail;
3070         } else
3071                 printf("third delete on close test succeeded.\n");
3072
3073         /* Test 4 ... */
3074         cli_setatr(cli1, fname, 0, 0);
3075         cli_unlink(cli1, fname);
3076
3077         fnum1 = cli_nt_create_full(cli1, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
3078                         FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OVERWRITE_IF, 0, 0);
3079
3080         if (fnum1 == -1) {
3081                 printf("[4] open of %s failed (%s)\n", fname, cli_errstr(cli1));
3082                 correct = False;
3083                 goto fail;
3084         }
3085
3086         /* This should succeed. */
3087         fnum2 = cli_nt_create_full(cli1, fname, 0, GENERIC_READ_ACCESS,
3088                         FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, FILE_OPEN, 0, 0);
3089         if (fnum2 == -1) {
3090                 printf("[4] open  - 2 of %s failed (%s)\n", fname, cli_errstr(cli1));
3091                 correct = False;
3092                 goto fail;
3093         }
3094
3095         if (!cli_close(cli1, fnum2)) {
3096                 printf("[4] close - 1 failed (%s)\n", cli_errstr(cli1));
3097                 correct = False;
3098                 goto fail;
3099         }
3100
3101         if (!cli_nt_delete_on_close(cli1, fnum1, True)) {
3102                 printf("[4] setting delete_on_close failed (%s)\n", cli_errstr(cli1));
3103                 correct = False;
3104                 goto fail;
3105         }
3106
3107         /* This should fail - no more opens once delete on close set. */
3108         fnum2 = cli_nt_create_full(cli1, fname, 0, GENERIC_READ_ACCESS,
3109                                    FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
3110                                    FILE_OPEN, 0, 0);
3111         if (fnum2 != -1) {
3112                 printf("[4] open  - 3 of %s succeeded ! Should have failed.\n", fname );
3113                 correct = False;
3114                 goto fail;
3115         } else
3116                 printf("fourth delete on close test succeeded.\n");
3117
3118         if (!cli_close(cli1, fnum1)) {
3119                 printf("[4] close - 2 failed (%s)\n", cli_errstr(cli1));
3120                 correct = False;
3121                 goto fail;
3122         }
3123
3124         /* Test 5 ... */
3125         cli_setatr(cli1, fname, 0, 0);
3126         cli_unlink(cli1, fname);
3127
3128         fnum1 = cli_open(cli1, fname, O_RDWR|O_CREAT, DENY_NONE);
3129         if (fnum1 == -1) {
3130                 printf("[5] open of %s failed (%s)\n", fname, cli_errstr(cli1));
3131                 correct = False;
3132                 goto fail;
3133         }
3134
3135         /* This should fail - only allowed on NT opens with DELETE access. */
3136
3137         if (cli_nt_delete_on_close(cli1, fnum1, True)) {
3138                 printf("[5] setting delete_on_close on OpenX file succeeded - should fail !\n");
3139                 correct = False;
3140                 goto fail;
3141         }
3142
3143         if (!cli_close(cli1, fnum1)) {
3144                 printf("[5] close - 2 failed (%s)\n", cli_errstr(cli1));
3145                 correct = False;
3146                 goto fail;
3147         }
3148
3149         printf("fifth delete on close test succeeded.\n");
3150
3151         /* Test 6 ... */
3152         cli_setatr(cli1, fname, 0, 0);
3153         cli_unlink(cli1, fname);
3154
3155         fnum1 = cli_nt_create_full(cli1, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA,
3156                                    FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
3157                                    FILE_OVERWRITE_IF, 0, 0);
3158
3159         if (fnum1 == -1) {
3160                 printf("[6] open of %s failed (%s)\n", fname, cli_errstr(cli1));
3161                 correct = False;
3162                 goto fail;
3163         }
3164
3165         /* This should fail - only allowed on NT opens with DELETE access. */
3166
3167         if (cli_nt_delete_on_close(cli1, fnum1, True)) {
3168                 printf("[6] setting delete_on_close on file with no delete access succeeded - should fail !\n");
3169                 correct = False;
3170                 goto fail;
3171         }
3172
3173         if (!cli_close(cli1, fnum1)) {
3174                 printf("[6] close - 2 failed (%s)\n", cli_errstr(cli1));
3175                 correct = False;
3176                 goto fail;
3177         }
3178
3179         printf("sixth delete on close test succeeded.\n");
3180
3181         /* Test 7 ... */
3182         cli_setatr(cli1, fname, 0, 0);
3183         cli_unlink(cli1, fname);
3184
3185         fnum1 = cli_nt_create_full(cli1, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
3186                                    FILE_ATTRIBUTE_NORMAL, 0, FILE_OVERWRITE_IF, 0, 0);
3187
3188         if (fnum1 == -1) {
3189                 printf("[7] open of %s failed (%s)\n", fname, cli_errstr(cli1));
3190                 correct = False;
3191                 goto fail;
3192         }
3193
3194         if (!cli_nt_delete_on_close(cli1, fnum1, True)) {
3195                 printf("[7] setting delete_on_close on file failed !\n");
3196                 correct = False;
3197                 goto fail;
3198         }
3199
3200         if (!cli_nt_delete_on_close(cli1, fnum1, False)) {
3201                 printf("[7] unsetting delete_on_close on file failed !\n");
3202                 correct = False;
3203                 goto fail;
3204         }
3205
3206         if (!cli_close(cli1, fnum1)) {
3207                 printf("[7] close - 2 failed (%s)\n", cli_errstr(cli1));
3208                 correct = False;
3209                 goto fail;
3210         }
3211
3212         /* This next open should succeed - we reset the flag. */
3213
3214         fnum1 = cli_open(cli1, fname, O_RDONLY, DENY_NONE);
3215         if (fnum1 == -1) {
3216                 printf("[5] open of %s failed (%s)\n", fname, cli_errstr(cli1));
3217                 correct = False;
3218                 goto fail;
3219         }
3220
3221         if (!cli_close(cli1, fnum1)) {
3222                 printf("[7] close - 2 failed (%s)\n", cli_errstr(cli1));
3223                 correct = False;
3224                 goto fail;
3225         }
3226
3227         printf("seventh delete on close test succeeded.\n");
3228
3229         /* Test 7 ... */
3230         cli_setatr(cli1, fname, 0, 0);
3231         cli_unlink(cli1, fname);
3232
3233         if (!torture_open_connection(&cli2, 1)) {
3234                 printf("[8] failed to open second connection.\n");
3235                 correct = False;
3236                 goto fail;
3237         }
3238
3239         cli_sockopt(cli1, sockops);
3240
3241         fnum1 = cli_nt_create_full(cli1, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
3242                                    FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
3243                                    FILE_OVERWRITE_IF, 0, 0);
3244
3245         if (fnum1 == -1) {
3246                 printf("[8] open 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
3247                 correct = False;
3248                 goto fail;
3249         }
3250
3251         fnum2 = cli_nt_create_full(cli2, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
3252                                    FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
3253                                    FILE_OPEN, 0, 0);
3254
3255         if (fnum2 == -1) {
3256                 printf("[8] open 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
3257                 correct = False;
3258                 goto fail;
3259         }
3260
3261         if (!cli_nt_delete_on_close(cli1, fnum1, True)) {
3262                 printf("[8] setting delete_on_close on file failed !\n");
3263                 correct = False;
3264                 goto fail;
3265         }
3266
3267         if (!cli_close(cli1, fnum1)) {
3268                 printf("[8] close - 1 failed (%s)\n", cli_errstr(cli1));
3269                 correct = False;
3270                 goto fail;
3271         }
3272
3273         if (!cli_close(cli2, fnum2)) {
3274                 printf("[8] close - 2 failed (%s)\n", cli_errstr(cli2));
3275                 correct = False;
3276                 goto fail;
3277         }
3278
3279         /* This should fail.. */
3280         fnum1 = cli_open(cli1, fname, O_RDONLY, DENY_NONE);
3281         if (fnum1 != -1) {
3282                 printf("[8] open of %s succeeded should have been deleted on close !\n", fname);
3283                 goto fail;
3284                 correct = False;
3285         } else
3286                 printf("eighth delete on close test succeeded.\n");
3287
3288         /* This should fail - we need to set DELETE_ACCESS. */
3289         fnum1 = cli_nt_create_full(cli1, fname, 0,FILE_READ_DATA|FILE_WRITE_DATA,
3290                                    FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE, FILE_OVERWRITE_IF, FILE_DELETE_ON_CLOSE, 0);
3291
3292         if (fnum1 != -1) {
3293                 printf("[9] open of %s succeeded should have failed!\n", fname);
3294                 correct = False;
3295                 goto fail;
3296         }
3297
3298         printf("ninth delete on close test succeeded.\n");
3299
3300         fnum1 = cli_nt_create_full(cli1, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
3301                                    FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE, FILE_OVERWRITE_IF, FILE_DELETE_ON_CLOSE, 0);
3302         if (fnum1 == -1) {
3303                 printf("[10] open of %s failed (%s)\n", fname, cli_errstr(cli1));
3304                 correct = False;
3305                 goto fail;
3306         }
3307
3308         /* This should delete the file. */
3309         if (!cli_close(cli1, fnum1)) {
3310                 printf("[10] close failed (%s)\n", cli_errstr(cli1));
3311                 correct = False;
3312                 goto fail;
3313         }
3314
3315         /* This should fail.. */
3316         fnum1 = cli_open(cli1, fname, O_RDONLY, DENY_NONE);
3317         if (fnum1 != -1) {
3318                 printf("[10] open of %s succeeded should have been deleted on close !\n", fname);
3319                 goto fail;
3320                 correct = False;
3321         } else
3322                 printf("tenth delete on close test succeeded.\n");
3323
3324         cli_setatr(cli1, fname, 0, 0);
3325         cli_unlink(cli1, fname);
3326
3327         /* What error do we get when attempting to open a read-only file with
3328            delete access ? */
3329
3330         /* Create a readonly file. */
3331         fnum1 = cli_nt_create_full(cli1, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA,
3332                                    FILE_ATTRIBUTE_READONLY, FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0);
3333         if (fnum1 == -1) {
3334                 printf("[11] open of %s failed (%s)\n", fname, cli_errstr(cli1));
3335                 correct = False;
3336                 goto fail;
3337         }
3338
3339         if (!cli_close(cli1, fnum1)) {
3340                 printf("[11] close failed (%s)\n", cli_errstr(cli1));
3341                 correct = False;
3342                 goto fail;
3343         }
3344
3345         /* Now try open for delete access. */
3346         fnum1 = cli_nt_create_full(cli1, fname, 0, FILE_READ_ATTRIBUTES|DELETE_ACCESS,
3347                                    0, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
3348                                    FILE_OVERWRITE_IF, 0, 0);
3349
3350         if (fnum1 != -1) {
3351                 printf("[11] open of %s succeeded should have been denied with ACCESS_DENIED!\n", fname);
3352                 cli_close(cli1, fnum1);
3353                 goto fail;
3354                 correct = False;
3355         } else {
3356                 NTSTATUS nterr = cli_nt_error(cli1);
3357                 if (!NT_STATUS_EQUAL(nterr,NT_STATUS_ACCESS_DENIED)) {
3358                         printf("[11] open of %s should have been denied with ACCESS_DENIED! Got error %s\n", fname, nt_errstr(nterr));
3359                         goto fail;
3360                         correct = False;
3361                 } else {
3362                         printf("eleventh delete on close test succeeded.\n");
3363                 }
3364         }
3365
3366         printf("finished delete test\n");
3367
3368   fail:
3369         /* FIXME: This will crash if we aborted before cli2 got
3370          * intialized, because these functions don't handle
3371          * uninitialized connections. */
3372
3373         if (fnum1 != -1) cli_close(cli1, fnum1);
3374         if (fnum2 != -1) cli_close(cli1, fnum2);
3375         cli_setatr(cli1, fname, 0, 0);
3376         cli_unlink(cli1, fname);
3377
3378         if (cli1 && !torture_close_connection(cli1)) {
3379                 correct = False;
3380         }
3381         if (cli2 && !torture_close_connection(cli2)) {
3382                 correct = False;
3383         }
3384         return correct;
3385 }
3386
3387
3388 /*
3389   print out server properties
3390  */
3391 static BOOL run_properties(int dummy)
3392 {
3393         static struct cli_state *cli;
3394         BOOL correct = True;
3395
3396         printf("starting properties test\n");
3397
3398         ZERO_STRUCT(cli);
3399
3400         if (!torture_open_connection(&cli, 0)) {
3401                 return False;
3402         }
3403
3404         cli_sockopt(cli, sockops);
3405
3406         d_printf("Capabilities 0x%08x\n", cli->capabilities);
3407
3408         if (!torture_close_connection(cli)) {
3409                 correct = False;
3410         }
3411
3412         return correct;
3413 }
3414
3415
3416
3417 /* FIRST_DESIRED_ACCESS   0xf019f */
3418 #define FIRST_DESIRED_ACCESS   FILE_READ_DATA|FILE_WRITE_DATA|FILE_APPEND_DATA|\
3419                                FILE_READ_EA|                           /* 0xf */ \
3420                                FILE_WRITE_EA|FILE_READ_ATTRIBUTES|     /* 0x90 */ \
3421                                FILE_WRITE_ATTRIBUTES|                  /* 0x100 */ \
3422                                DELETE_ACCESS|READ_CONTROL_ACCESS|\
3423                                WRITE_DAC_ACCESS|WRITE_OWNER_ACCESS     /* 0xf0000 */
3424 /* SECOND_DESIRED_ACCESS  0xe0080 */
3425 #define SECOND_DESIRED_ACCESS  FILE_READ_ATTRIBUTES|                   /* 0x80 */ \
3426                                READ_CONTROL_ACCESS|WRITE_DAC_ACCESS|\
3427                                WRITE_OWNER_ACCESS                      /* 0xe0000 */
3428
3429 #if 0
3430 #define THIRD_DESIRED_ACCESS   FILE_READ_ATTRIBUTES|                   /* 0x80 */ \
3431                                READ_CONTROL_ACCESS|WRITE_DAC_ACCESS|\
3432                                FILE_READ_DATA|\
3433                                WRITE_OWNER_ACCESS                      /* */
3434 #endif
3435
3436 /*
3437   Test ntcreate calls made by xcopy
3438  */
3439 static BOOL run_xcopy(int dummy)
3440 {
3441         static struct cli_state *cli1;
3442         const char *fname = "\\test.txt";
3443         BOOL correct = True;
3444         int fnum1, fnum2;
3445
3446         printf("starting xcopy test\n");
3447
3448         if (!torture_open_connection(&cli1, 0)) {
3449                 return False;
3450         }
3451
3452         fnum1 = cli_nt_create_full(cli1, fname, 0,
3453                                    FIRST_DESIRED_ACCESS, FILE_ATTRIBUTE_ARCHIVE,
3454                                    FILE_SHARE_NONE, FILE_OVERWRITE_IF,
3455                                    0x4044, 0);
3456
3457         if (fnum1 == -1) {
3458                 printf("First open failed - %s\n", cli_errstr(cli1));
3459                 return False;
3460         }
3461
3462         fnum2 = cli_nt_create_full(cli1, fname, 0,
3463                                    SECOND_DESIRED_ACCESS, 0,
3464                                    FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, FILE_OPEN,
3465                                    0x200000, 0);
3466         if (fnum2 == -1) {
3467                 printf("second open failed - %s\n", cli_errstr(cli1));
3468                 return False;
3469         }
3470
3471         if (!torture_close_connection(cli1)) {
3472                 correct = False;
3473         }
3474
3475         return correct;
3476 }
3477
3478 /*
3479   Test rename on files open with share delete and no share delete.
3480  */
3481 static BOOL run_rename(int dummy)
3482 {
3483         static struct cli_state *cli1;
3484         const char *fname = "\\test.txt";
3485         const char *fname1 = "\\test1.txt";
3486         BOOL correct = True;
3487         int fnum1;
3488
3489         printf("starting rename test\n");
3490
3491         if (!torture_open_connection(&cli1, 0)) {
3492                 return False;
3493         }
3494
3495         cli_unlink(cli1, fname);
3496         cli_unlink(cli1, fname1);
3497         fnum1 = cli_nt_create_full(cli1, fname, 0, GENERIC_READ_ACCESS, FILE_ATTRIBUTE_NORMAL,
3498                                    FILE_SHARE_READ, FILE_OVERWRITE_IF, 0, 0);
3499
3500         if (fnum1 == -1) {
3501                 printf("First open failed - %s\n", cli_errstr(cli1));
3502                 return False;
3503         }
3504
3505         if (!cli_rename(cli1, fname, fname1)) {
3506                 printf("First rename failed (SHARE_READ) (this is correct) - %s\n", cli_errstr(cli1));
3507         } else {
3508                 printf("First rename succeeded (SHARE_READ) - this should have failed !\n");
3509                 correct = False;
3510         }
3511
3512         if (!cli_close(cli1, fnum1)) {
3513                 printf("close - 1 failed (%s)\n", cli_errstr(cli1));
3514                 return False;
3515         }
3516
3517         cli_unlink(cli1, fname);
3518         cli_unlink(cli1, fname1);
3519         fnum1 = cli_nt_create_full(cli1, fname, 0, GENERIC_READ_ACCESS, FILE_ATTRIBUTE_NORMAL,
3520 #if 0
3521                                    FILE_SHARE_DELETE|FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0);
3522 #else
3523                                    FILE_SHARE_DELETE|FILE_SHARE_READ, FILE_OVERWRITE_IF, 0, 0);
3524 #endif
3525
3526         if (fnum1 == -1) {
3527                 printf("Second open failed - %s\n", cli_errstr(cli1));
3528                 return False;
3529         }
3530
3531         if (!cli_rename(cli1, fname, fname1)) {
3532                 printf("Second rename failed (SHARE_DELETE | SHARE_READ) - this should have succeeded - %s\n", cli_errstr(cli1));
3533                 correct = False;
3534         } else {
3535                 printf("Second rename succeeded (SHARE_DELETE | SHARE_READ)\n");
3536         }
3537
3538         if (!cli_close(cli1, fnum1)) {
3539                 printf("close - 2 failed (%s)\n", cli_errstr(cli1));
3540                 return False;
3541         }
3542
3543         cli_unlink(cli1, fname);
3544         cli_unlink(cli1, fname1);
3545
3546         fnum1 = cli_nt_create_full(cli1, fname, 0, READ_CONTROL_ACCESS, FILE_ATTRIBUTE_NORMAL,
3547                                    FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0);
3548
3549         if (fnum1 == -1) {
3550                 printf("Third open failed - %s\n", cli_errstr(cli1));
3551                 return False;
3552         }
3553
3554
3555 #if 0
3556   {
3557   int fnum2;
3558
3559         fnum2 = cli_nt_create_full(cli1, fname, 0, DELETE_ACCESS, FILE_ATTRIBUTE_NORMAL,
3560                                    FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0);
3561
3562         if (fnum2 == -1) {
3563                 printf("Fourth open failed - %s\n", cli_errstr(cli1));
3564                 return False;
3565         }
3566         if (!cli_nt_delete_on_close(cli1, fnum2, True)) {
3567                 printf("[8] setting delete_on_close on file failed !\n");
3568                 return False;
3569         }
3570
3571         if (!cli_close(cli1, fnum2)) {
3572                 printf("close - 4 failed (%s)\n", cli_errstr(cli1));
3573                 return False;
3574         }
3575   }
3576 #endif
3577
3578         if (!cli_rename(cli1, fname, fname1)) {
3579                 printf("Third rename failed (SHARE_NONE) - this should have succeeded - %s\n", cli_errstr(cli1));
3580                 correct = False;
3581         } else {
3582                 printf("Third rename succeeded (SHARE_NONE)\n");
3583         }
3584
3585         if (!cli_close(cli1, fnum1)) {
3586                 printf("close - 3 failed (%s)\n", cli_errstr(cli1));
3587                 return False;
3588         }
3589
3590         cli_unlink(cli1, fname);
3591         cli_unlink(cli1, fname1);
3592
3593         /*----*/
3594
3595         fnum1 = cli_nt_create_full(cli1, fname, 0, GENERIC_READ_ACCESS, FILE_ATTRIBUTE_NORMAL,
3596                                    FILE_SHARE_READ | FILE_SHARE_WRITE, FILE_OVERWRITE_IF, 0, 0);
3597
3598         if (fnum1 == -1) {
3599                 printf("Fourth open failed - %s\n", cli_errstr(cli1));
3600                 return False;
3601         }
3602
3603         if (!cli_rename(cli1, fname, fname1)) {
3604                 printf("Fourth rename failed (SHARE_READ | SHARE_WRITE) (this is correct) - %s\n", cli_errstr(cli1));
3605         } else {
3606                 printf("Fourth rename succeeded (SHARE_READ | SHARE_WRITE) - this should have failed !\n");
3607                 correct = False;
3608         }
3609
3610         if (!cli_close(cli1, fnum1)) {
3611                 printf("close - 4 failed (%s)\n", cli_errstr(cli1));
3612                 return False;
3613         }
3614
3615         cli_unlink(cli1, fname);
3616         cli_unlink(cli1, fname1);
3617
3618         /*--*/
3619
3620         fnum1 = cli_nt_create_full(cli1, fname, 0, GENERIC_READ_ACCESS, FILE_ATTRIBUTE_NORMAL,
3621                                    FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, FILE_OVERWRITE_IF, 0, 0);
3622
3623         if (fnum1 == -1) {
3624                 printf("Fifth open failed - %s\n", cli_errstr(cli1));
3625                 return False;
3626         }
3627
3628         if (!cli_rename(cli1, fname, fname1)) {
3629                 printf("Fifth rename failed (SHARE_READ | SHARE_WRITE | SHARE_DELETE) - this should have failed ! \n");
3630                 correct = False;
3631         } else {
3632                 printf("Fifth rename succeeded (SHARE_READ | SHARE_WRITE | SHARE_DELETE) (this is correct) - %s\n", cli_errstr(cli1));
3633         }
3634
3635         /*
3636          * Now check if the first name still exists ...
3637          */
3638
3639         /*fnum2 = cli_nt_create_full(cli1, fname, 0, GENERIC_READ_ACCESS, FILE_ATTRIBUTE_NORMAL,
3640                                    FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, FILE_OVERWRITE_IF, 0, 0);
3641
3642         if (fnum2 == -1) {
3643           printf("Opening original file after rename of open file fails: %s\n",
3644               cli_errstr(cli1));
3645         }
3646         else {
3647           printf("Opening original file after rename of open file works ...\n");
3648           (void)cli_close(cli1, fnum2);
3649           } */
3650
3651         /*--*/
3652
3653
3654         if (!cli_close(cli1, fnum1)) {
3655                 printf("close - 5 failed (%s)\n", cli_errstr(cli1));
3656                 return False;
3657         }
3658
3659         cli_unlink(cli1, fname);
3660         cli_unlink(cli1, fname1);
3661
3662         if (!torture_close_connection(cli1)) {
3663                 correct = False;
3664         }
3665
3666         return correct;
3667 }
3668
3669 static BOOL run_pipe_number(int dummy)
3670 {
3671         struct cli_state *cli1;
3672         const char *pipe_name = "\\SPOOLSS";
3673         int fnum;
3674         int num_pipes = 0;
3675
3676         printf("starting pipenumber test\n");
3677         if (!torture_open_connection(&cli1, 0)) {
3678                 return False;
3679         }
3680
3681         cli_sockopt(cli1, sockops);
3682         while(1) {
3683                 fnum = cli_nt_create_full(cli1, pipe_name, 0, FILE_READ_DATA, FILE_ATTRIBUTE_NORMAL,
3684                                    FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OPEN_IF, 0, 0);
3685
3686                 if (fnum == -1) {
3687                         printf("Open of pipe %s failed with error (%s)\n", pipe_name, cli_errstr(cli1));
3688                         break;
3689                 }
3690                 num_pipes++;
3691                 printf("\r%6d", num_pipes);
3692         }
3693
3694         printf("pipe_number test - we can open %d %s pipes.\n", num_pipes, pipe_name );
3695         torture_close_connection(cli1);
3696         return True;
3697 }
3698
3699 /*
3700   Test open mode returns on read-only files.
3701  */
3702 static BOOL run_opentest(int dummy)
3703 {
3704         static struct cli_state *cli1;
3705         static struct cli_state *cli2;
3706         const char *fname = "\\readonly.file";
3707         int fnum1, fnum2;
3708         char buf[20];
3709         SMB_OFF_T fsize;
3710         BOOL correct = True;
3711         char *tmp_path;
3712
3713         printf("starting open test\n");
3714
3715         if (!torture_open_connection(&cli1, 0)) {
3716                 return False;
3717         }
3718
3719         cli_setatr(cli1, fname, 0, 0);
3720         cli_unlink(cli1, fname);
3721
3722         cli_sockopt(cli1, sockops);
3723
3724         fnum1 = cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
3725         if (fnum1 == -1) {
3726                 printf("open of %s failed (%s)\n", fname, cli_errstr(cli1));
3727                 return False;
3728         }
3729
3730         if (!cli_close(cli1, fnum1)) {
3731                 printf("close2 failed (%s)\n", cli_errstr(cli1));
3732                 return False;
3733         }
3734
3735         if (!cli_setatr(cli1, fname, aRONLY, 0)) {
3736                 printf("cli_setatr failed (%s)\n", cli_errstr(cli1));
3737                 return False;
3738         }
3739
3740         fnum1 = cli_open(cli1, fname, O_RDONLY, DENY_WRITE);
3741         if (fnum1 == -1) {
3742                 printf("open of %s failed (%s)\n", fname, cli_errstr(cli1));
3743                 return False;
3744         }
3745
3746         /* This will fail - but the error should be ERRnoaccess, not ERRbadshare. */
3747         fnum2 = cli_open(cli1, fname, O_RDWR, DENY_ALL);
3748
3749         if (check_error(__LINE__, cli1, ERRDOS, ERRnoaccess,
3750                         NT_STATUS_ACCESS_DENIED)) {
3751                 printf("correct error code ERRDOS/ERRnoaccess returned\n");
3752         }
3753
3754         printf("finished open test 1\n");
3755
3756         cli_close(cli1, fnum1);
3757
3758         /* Now try not readonly and ensure ERRbadshare is returned. */
3759
3760         cli_setatr(cli1, fname, 0, 0);
3761
3762         fnum1 = cli_open(cli1, fname, O_RDONLY, DENY_WRITE);
3763         if (fnum1 == -1) {
3764                 printf("open of %s failed (%s)\n", fname, cli_errstr(cli1));
3765                 return False;
3766         }
3767
3768         /* This will fail - but the error should be ERRshare. */
3769         fnum2 = cli_open(cli1, fname, O_RDWR, DENY_ALL);
3770
3771         if (check_error(__LINE__, cli1, ERRDOS, ERRbadshare,
3772                         NT_STATUS_SHARING_VIOLATION)) {
3773                 printf("correct error code ERRDOS/ERRbadshare returned\n");
3774         }
3775
3776         if (!cli_close(cli1, fnum1)) {
3777                 printf("close2 failed (%s)\n", cli_errstr(cli1));
3778                 return False;
3779         }
3780
3781         cli_unlink(cli1, fname);
3782
3783         printf("finished open test 2\n");
3784
3785         /* Test truncate open disposition on file opened for read. */
3786
3787         fnum1 = cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
3788         if (fnum1 == -1) {
3789                 printf("(3) open (1) of %s failed (%s)\n", fname, cli_errstr(cli1));
3790                 return False;
3791         }
3792
3793         /* write 20 bytes. */
3794
3795         memset(buf, '\0', 20);
3796
3797         if (cli_write(cli1, fnum1, 0, buf, 0, 20) != 20) {
3798                 printf("write failed (%s)\n", cli_errstr(cli1));
3799                 correct = False;
3800         }
3801
3802         if (!cli_close(cli1, fnum1)) {
3803                 printf("(3) close1 failed (%s)\n", cli_errstr(cli1));
3804                 return False;
3805         }
3806
3807         /* Ensure size == 20. */
3808         if (!cli_getatr(cli1, fname, NULL, &fsize, NULL)) {
3809                 printf("(3) getatr failed (%s)\n", cli_errstr(cli1));
3810                 return False;
3811         }
3812
3813         if (fsize != 20) {
3814                 printf("(3) file size != 20\n");
3815                 return False;
3816         }
3817
3818         /* Now test if we can truncate a file opened for readonly. */
3819
3820         fnum1 = cli_open(cli1, fname, O_RDONLY|O_TRUNC, DENY_NONE);
3821         if (fnum1 == -1) {
3822                 printf("(3) open (2) of %s failed (%s)\n", fname, cli_errstr(cli1));
3823                 return False;
3824         }
3825
3826         if (!cli_close(cli1, fnum1)) {
3827                 printf("close2 failed (%s)\n", cli_errstr(cli1));
3828                 return False;
3829         }
3830
3831         /* Ensure size == 0. */
3832         if (!cli_getatr(cli1, fname, NULL, &fsize, NULL)) {
3833                 printf("(3) getatr failed (%s)\n", cli_errstr(cli1));
3834                 return False;
3835         }
3836
3837         if (fsize != 0) {
3838                 printf("(3) file size != 0\n");
3839                 return False;
3840         }
3841         printf("finished open test 3\n");
3842
3843         cli_unlink(cli1, fname);
3844
3845
3846         printf("testing ctemp\n");
3847         fnum1 = cli_ctemp(cli1, "\\", &tmp_path);
3848         if (fnum1 == -1) {
3849                 printf("ctemp failed (%s)\n", cli_errstr(cli1));
3850                 return False;
3851         }
3852         printf("ctemp gave path %s\n", tmp_path);
3853         if (!cli_close(cli1, fnum1)) {
3854                 printf("close of temp failed (%s)\n", cli_errstr(cli1));
3855         }
3856         if (!cli_unlink(cli1, tmp_path)) {
3857                 printf("unlink of temp failed (%s)\n", cli_errstr(cli1));
3858         }
3859
3860         /* Test the non-io opens... */
3861
3862         if (!torture_open_connection(&cli2, 1)) {
3863                 return False;
3864         }
3865
3866         cli_setatr(cli2, fname, 0, 0);
3867         cli_unlink(cli2, fname);
3868
3869         cli_sockopt(cli2, sockops);
3870
3871         printf("TEST #1 testing 2 non-io opens (no delete)\n");
3872
3873         fnum1 = cli_nt_create_full(cli1, fname, 0, FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
3874                                    FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0);
3875
3876         if (fnum1 == -1) {
3877                 printf("test 1 open 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
3878                 return False;
3879         }
3880
3881         fnum2 = cli_nt_create_full(cli2, fname, 0, FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
3882                                    FILE_SHARE_NONE, FILE_OPEN_IF, 0, 0);
3883
3884         if (fnum2 == -1) {
3885                 printf("test 1 open 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
3886                 return False;
3887         }
3888
3889         if (!cli_close(cli1, fnum1)) {
3890                 printf("test 1 close 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
3891                 return False;
3892         }
3893         if (!cli_close(cli2, fnum2)) {
3894                 printf("test 1 close 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
3895                 return False;
3896         }
3897
3898         printf("non-io open test #1 passed.\n");
3899
3900         cli_unlink(cli1, fname);
3901
3902         printf("TEST #2 testing 2 non-io opens (first with delete)\n");
3903
3904         fnum1 = cli_nt_create_full(cli1, fname, 0, DELETE_ACCESS|FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
3905                                    FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0);
3906
3907         if (fnum1 == -1) {
3908                 printf("test 2 open 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
3909                 return False;
3910         }
3911
3912         fnum2 = cli_nt_create_full(cli2, fname, 0, FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
3913                                    FILE_SHARE_NONE, FILE_OPEN_IF, 0, 0);
3914
3915         if (fnum2 == -1) {
3916                 printf("test 2 open 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
3917                 return False;
3918         }
3919
3920         if (!cli_close(cli1, fnum1)) {
3921                 printf("test 1 close 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
3922                 return False;
3923         }
3924         if (!cli_close(cli2, fnum2)) {
3925                 printf("test 1 close 2 of %s failed (%s)\n", fname, cli_errstr(cli1));
3926                 return False;
3927         }
3928
3929         printf("non-io open test #2 passed.\n");
3930
3931         cli_unlink(cli1, fname);
3932
3933         printf("TEST #3 testing 2 non-io opens (second with delete)\n");
3934
3935         fnum1 = cli_nt_create_full(cli1, fname, 0, FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
3936                                    FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0);
3937
3938         if (fnum1 == -1) {
3939                 printf("test 3 open 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
3940                 return False;
3941         }
3942
3943         fnum2 = cli_nt_create_full(cli2, fname, 0, DELETE_ACCESS|FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
3944                                    FILE_SHARE_NONE, FILE_OPEN_IF, 0, 0);
3945
3946         if (fnum2 == -1) {
3947                 printf("test 3 open 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
3948                 return False;
3949         }
3950
3951         if (!cli_close(cli1, fnum1)) {
3952                 printf("test 3 close 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
3953                 return False;
3954         }
3955         if (!cli_close(cli2, fnum2)) {
3956                 printf("test 3 close 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
3957                 return False;
3958         }
3959
3960         printf("non-io open test #3 passed.\n");
3961
3962         cli_unlink(cli1, fname);
3963
3964         printf("TEST #4 testing 2 non-io opens (both with delete)\n");
3965
3966         fnum1 = cli_nt_create_full(cli1, fname, 0, DELETE_ACCESS|FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
3967                                    FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0);
3968
3969         if (fnum1 == -1) {
3970                 printf("test 4 open 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
3971                 return False;
3972         }
3973
3974         fnum2 = cli_nt_create_full(cli2, fname, 0, DELETE_ACCESS|FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
3975                                    FILE_SHARE_NONE, FILE_OPEN_IF, 0, 0);
3976
3977         if (fnum2 != -1) {
3978                 printf("test 4 open 2 of %s SUCCEEDED - should have failed (%s)\n", fname, cli_errstr(cli2));
3979                 return False;
3980         }
3981
3982         printf("test 3 open 2 of %s gave %s (correct error should be %s)\n", fname, cli_errstr(cli2), "sharing violation");
3983
3984         if (!cli_close(cli1, fnum1)) {
3985                 printf("test 4 close 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
3986                 return False;
3987         }
3988
3989         printf("non-io open test #4 passed.\n");
3990
3991         cli_unlink(cli1, fname);
3992
3993         printf("TEST #5 testing 2 non-io opens (both with delete - both with file share delete)\n");
3994
3995         fnum1 = cli_nt_create_full(cli1, fname, 0, DELETE_ACCESS|FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
3996                                    FILE_SHARE_DELETE, FILE_OVERWRITE_IF, 0, 0);
3997
3998         if (fnum1 == -1) {
3999                 printf("test 5 open 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
4000                 return False;
4001         }
4002
4003         fnum2 = cli_nt_create_full(cli2, fname, 0, DELETE_ACCESS|FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
4004                                    FILE_SHARE_DELETE, FILE_OPEN_IF, 0, 0);
4005
4006         if (fnum2 == -1) {
4007                 printf("test 5 open 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
4008                 return False;
4009         }
4010
4011         if (!cli_close(cli1, fnum1)) {
4012                 printf("test 5 close 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
4013                 return False;
4014         }
4015
4016         if (!cli_close(cli2, fnum2)) {
4017                 printf("test 5 close 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
4018                 return False;
4019         }
4020
4021         printf("non-io open test #5 passed.\n");
4022
4023         printf("TEST #6 testing 1 non-io open, one io open\n");
4024
4025         cli_unlink(cli1, fname);
4026
4027         fnum1 = cli_nt_create_full(cli1, fname, 0, FILE_READ_DATA, FILE_ATTRIBUTE_NORMAL,
4028                                    FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0);
4029
4030         if (fnum1 == -1) {
4031                 printf("test 6 open 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
4032                 return False;
4033         }
4034
4035         fnum2 = cli_nt_create_full(cli2, fname, 0, FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
4036                                    FILE_SHARE_READ, FILE_OPEN_IF, 0, 0);
4037
4038         if (fnum2 == -1) {
4039                 printf("test 6 open 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
4040                 return False;
4041         }
4042
4043         if (!cli_close(cli1, fnum1)) {
4044                 printf("test 6 close 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
4045                 return False;
4046         }
4047
4048         if (!cli_close(cli2, fnum2)) {
4049                 printf("test 6 close 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
4050                 return False;
4051         }
4052
4053         printf("non-io open test #6 passed.\n");
4054
4055         printf("TEST #7 testing 1 non-io open, one io open with delete\n");
4056
4057         cli_unlink(cli1, fname);
4058
4059         fnum1 = cli_nt_create_full(cli1, fname, 0, FILE_READ_DATA, FILE_ATTRIBUTE_NORMAL,
4060                                    FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0);
4061
4062         if (fnum1 == -1) {
4063                 printf("test 7 open 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
4064                 return False;
4065         }
4066
4067         fnum2 = cli_nt_create_full(cli2, fname, 0, DELETE_ACCESS|FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
4068                                    FILE_SHARE_READ|FILE_SHARE_DELETE, FILE_OPEN_IF, 0, 0);
4069
4070         if (fnum2 != -1) {
4071                 printf("test 7 open 2 of %s SUCCEEDED - should have failed (%s)\n", fname, cli_errstr(cli2));
4072                 return False;
4073         }
4074
4075         printf("test 7 open 2 of %s gave %s (correct error should be %s)\n", fname, cli_errstr(cli2), "sharing violation");
4076
4077         if (!cli_close(cli1, fnum1)) {
4078                 printf("test 7 close 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
4079                 return False;
4080         }
4081
4082         printf("non-io open test #7 passed.\n");
4083
4084         cli_unlink(cli1, fname);
4085
4086         if (!torture_close_connection(cli1)) {
4087                 correct = False;
4088         }
4089         if (!torture_close_connection(cli2)) {
4090                 correct = False;
4091         }
4092
4093         return correct;
4094 }
4095
4096 static uint32 open_attrs_table[] = {
4097                 FILE_ATTRIBUTE_NORMAL,
4098                 FILE_ATTRIBUTE_ARCHIVE,
4099                 FILE_ATTRIBUTE_READONLY,
4100                 FILE_ATTRIBUTE_HIDDEN,
4101                 FILE_ATTRIBUTE_SYSTEM,
4102
4103                 FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY,
4104                 FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN,
4105                 FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM,
4106                 FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN,
4107                 FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM,
4108                 FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN|FILE_ATTRIBUTE_SYSTEM,
4109
4110                 FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN,
4111                 FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM,
4112                 FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN|FILE_ATTRIBUTE_SYSTEM,
4113                 FILE_ATTRIBUTE_HIDDEN,FILE_ATTRIBUTE_SYSTEM,
4114 };
4115
4116 struct trunc_open_results {
4117         unsigned int num;
4118         uint32 init_attr;
4119         uint32 trunc_attr;
4120         uint32 result_attr;
4121 };
4122
4123 static struct trunc_open_results attr_results[] = {
4124         { 0, FILE_ATTRIBUTE_NORMAL, FILE_ATTRIBUTE_NORMAL, FILE_ATTRIBUTE_ARCHIVE },
4125         { 1, FILE_ATTRIBUTE_NORMAL, FILE_ATTRIBUTE_ARCHIVE, FILE_ATTRIBUTE_ARCHIVE },
4126         { 2, FILE_ATTRIBUTE_NORMAL, FILE_ATTRIBUTE_READONLY, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY },
4127         { 16, FILE_ATTRIBUTE_ARCHIVE, FILE_ATTRIBUTE_NORMAL, FILE_ATTRIBUTE_ARCHIVE },
4128         { 17, FILE_ATTRIBUTE_ARCHIVE, FILE_ATTRIBUTE_ARCHIVE, FILE_ATTRIBUTE_ARCHIVE },
4129         { 18, FILE_ATTRIBUTE_ARCHIVE, FILE_ATTRIBUTE_READONLY, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY },
4130         { 51, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN },
4131         { 54, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN },
4132         { 56, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN },
4133         { 68, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM },
4134         { 71, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM },
4135         { 73, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM },
4136         { 99, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_HIDDEN,FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN },
4137         { 102, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN },
4138         { 104, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN },
4139         { 116, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM },
4140         { 119,  FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM,  FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM },
4141         { 121, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM },
4142         { 170, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM|FILE_ATTRIBUTE_HIDDEN },
4143         { 173, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN|FILE_ATTRIBUTE_SYSTEM },
4144         { 227, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN },
4145         { 230, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN },
4146         { 232, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN },
4147         { 244, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM },
4148         { 247, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM },
4149         { 249, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM }
4150 };
4151
4152 static BOOL run_openattrtest(int dummy)
4153 {
4154         static struct cli_state *cli1;
4155         const char *fname = "\\openattr.file";
4156         int fnum1;
4157         BOOL correct = True;
4158         uint16 attr;
4159         unsigned int i, j, k, l;
4160
4161         printf("starting open attr test\n");
4162
4163         if (!torture_open_connection(&cli1, 0)) {
4164                 return False;
4165         }
4166
4167         cli_sockopt(cli1, sockops);
4168
4169         for (k = 0, i = 0; i < sizeof(open_attrs_table)/sizeof(uint32); i++) {
4170                 cli_setatr(cli1, fname, 0, 0);
4171                 cli_unlink(cli1, fname);
4172                 fnum1 = cli_nt_create_full(cli1, fname, 0, FILE_WRITE_DATA, open_attrs_table[i],
4173                                    FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0);
4174
4175                 if (fnum1 == -1) {
4176                         printf("open %d (1) of %s failed (%s)\n", i, fname, cli_errstr(cli1));
4177                         return False;
4178                 }
4179
4180                 if (!cli_close(cli1, fnum1)) {
4181                         printf("close %d (1) of %s failed (%s)\n", i, fname, cli_errstr(cli1));
4182                         return False;
4183                 }
4184
4185                 for (j = 0; j < sizeof(open_attrs_table)/sizeof(uint32); j++) {
4186                         fnum1 = cli_nt_create_full(cli1, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA, open_attrs_table[j],
4187                                            FILE_SHARE_NONE, FILE_OVERWRITE, 0, 0);
4188
4189                         if (fnum1 == -1) {
4190                                 for (l = 0; l < sizeof(attr_results)/sizeof(struct trunc_open_results); l++) {
4191                                         if (attr_results[l].num == k) {
4192                                                 printf("[%d] trunc open 0x%x -> 0x%x of %s failed - should have succeeded !(0x%x:%s)\n",
4193                                                                 k, open_attrs_table[i],
4194                                                                 open_attrs_table[j],
4195                                                                 fname, NT_STATUS_V(cli_nt_error(cli1)), cli_errstr(cli1));
4196                                                 correct = False;
4197                                         }
4198                                 }
4199                                 if (NT_STATUS_V(cli_nt_error(cli1)) != NT_STATUS_V(NT_STATUS_ACCESS_DENIED)) {
4200                                         printf("[%d] trunc open 0x%x -> 0x%x failed with wrong error code %s\n",
4201                                                         k, open_attrs_table[i], open_attrs_table[j],
4202                                                         cli_errstr(cli1));
4203                                         correct = False;
4204                                 }
4205 #if 0
4206                                 printf("[%d] trunc open 0x%x -> 0x%x failed\n", k, open_attrs_table[i], open_attrs_table[j]);
4207 #endif
4208                                 k++;
4209                                 continue;
4210                         }
4211
4212                         if (!cli_close(cli1, fnum1)) {
4213                                 printf("close %d (2) of %s failed (%s)\n", j, fname, cli_errstr(cli1));
4214                                 return False;
4215                         }
4216
4217                         if (!cli_getatr(cli1, fname, &attr, NULL, NULL)) {
4218                                 printf("getatr(2) failed (%s)\n", cli_errstr(cli1));
4219                                 return False;
4220                         }
4221
4222 #if 0
4223                         printf("[%d] getatr check [0x%x] trunc [0x%x] got attr 0x%x\n",
4224                                         k,  open_attrs_table[i],  open_attrs_table[j], attr );
4225 #endif
4226
4227                         for (l = 0; l < sizeof(attr_results)/sizeof(struct trunc_open_results); l++) {
4228                                 if (attr_results[l].num == k) {
4229                                         if (attr != attr_results[l].result_attr ||
4230                                                         open_attrs_table[i] != attr_results[l].init_attr ||
4231                                                         open_attrs_table[j] != attr_results[l].trunc_attr) {
4232                                                 printf("getatr check failed. [0x%x] trunc [0x%x] got attr 0x%x, should be 0x%x\n",
4233                                                 open_attrs_table[i],
4234                                                 open_attrs_table[j],
4235                                                 (unsigned int)attr,
4236                                                 attr_results[l].result_attr);
4237                                                 correct = False;
4238                                         }
4239                                         break;
4240                                 }
4241                         }
4242                         k++;
4243                 }
4244         }
4245
4246         cli_setatr(cli1, fname, 0, 0);
4247         cli_unlink(cli1, fname);
4248
4249         printf("open attr test %s.\n", correct ? "passed" : "failed");
4250
4251         if (!torture_close_connection(cli1)) {
4252                 correct = False;
4253         }
4254         return correct;
4255 }
4256
4257 static void list_fn(const char *mnt, file_info *finfo, const char *name, void *state)
4258 {
4259
4260 }
4261
4262 /*
4263   test directory listing speed
4264  */
4265 static BOOL run_dirtest(int dummy)
4266 {
4267         int i;
4268         static struct cli_state *cli;
4269         int fnum;
4270         double t1;
4271         BOOL correct = True;
4272
4273         printf("starting directory test\n");
4274
4275         if (!torture_open_connection(&cli, 0)) {
4276                 return False;
4277         }
4278
4279         cli_sockopt(cli, sockops);
4280
4281         srandom(0);
4282         for (i=0;i<torture_numops;i++) {
4283                 fstring fname;
4284                 slprintf(fname, sizeof(fname), "\\%x", (int)random());
4285                 fnum = cli_open(cli, fname, O_RDWR|O_CREAT, DENY_NONE);
4286                 if (fnum == -1) {
4287                         fprintf(stderr,"Failed to open %s\n", fname);
4288                         return False;
4289                 }
4290                 cli_close(cli, fnum);
4291         }
4292
4293         t1 = end_timer();
4294
4295         printf("Matched %d\n", cli_list(cli, "a*.*", 0, list_fn, NULL));
4296         printf("Matched %d\n", cli_list(cli, "b*.*", 0, list_fn, NULL));
4297         printf("Matched %d\n", cli_list(cli, "xyzabc", 0, list_fn, NULL));
4298
4299         printf("dirtest core %g seconds\n", end_timer() - t1);
4300
4301         srandom(0);
4302         for (i=0;i<torture_numops;i++) {
4303                 fstring fname;
4304                 slprintf(fname, sizeof(fname), "\\%x", (int)random());
4305                 cli_unlink(cli, fname);
4306         }
4307
4308         if (!torture_close_connection(cli)) {
4309                 correct = False;
4310         }
4311
4312         printf("finished dirtest\n");
4313
4314         return correct;
4315 }
4316
4317 static void del_fn(const char *mnt, file_info *finfo, const char *mask, void *state)
4318 {
4319         struct cli_state *pcli = (struct cli_state *)state;
4320         fstring fname;
4321         slprintf(fname, sizeof(fname), "\\LISTDIR\\%s", finfo->name);
4322
4323         if (strcmp(finfo->name, ".") == 0 || strcmp(finfo->name, "..") == 0)
4324                 return;
4325
4326         if (finfo->mode & aDIR) {
4327                 if (!cli_rmdir(pcli, fname))
4328                         printf("del_fn: failed to rmdir %s\n,", fname );
4329         } else {
4330                 if (!cli_unlink(pcli, fname))
4331                         printf("del_fn: failed to unlink %s\n,", fname );
4332         }
4333 }
4334
4335
4336 /*
4337   sees what IOCTLs are supported
4338  */
4339 BOOL torture_ioctl_test(int dummy)
4340 {
4341         static struct cli_state *cli;
4342         uint16 device, function;
4343         int fnum;
4344         const char *fname = "\\ioctl.dat";
4345         DATA_BLOB blob;
4346         NTSTATUS status;
4347
4348         if (!torture_open_connection(&cli, 0)) {
4349                 return False;
4350         }
4351
4352         printf("starting ioctl test\n");
4353
4354         cli_unlink(cli, fname);
4355
4356         fnum = cli_open(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
4357         if (fnum == -1) {
4358                 printf("open of %s failed (%s)\n", fname, cli_errstr(cli));
4359                 return False;
4360         }
4361
4362         status = cli_raw_ioctl(cli, fnum, 0x2d0000 | (0x0420<<2), &blob);
4363         printf("ioctl device info: %s\n", cli_errstr(cli));
4364
4365         status = cli_raw_ioctl(cli, fnum, IOCTL_QUERY_JOB_INFO, &blob);
4366         printf("ioctl job info: %s\n", cli_errstr(cli));
4367
4368         for (device=0;device<0x100;device++) {
4369                 printf("testing device=0x%x\n", device);
4370                 for (function=0;function<0x100;function++) {
4371                         uint32 code = (device<<16) | function;
4372
4373                         status = cli_raw_ioctl(cli, fnum, code, &blob);
4374
4375                         if (NT_STATUS_IS_OK(status)) {
4376                                 printf("ioctl 0x%x OK : %d bytes\n", (int)code,
4377                                        (int)blob.length);
4378                                 data_blob_free(&blob);
4379                         }
4380                 }
4381         }
4382
4383         if (!torture_close_connection(cli)) {
4384                 return False;
4385         }
4386
4387         return True;
4388 }
4389
4390
4391 /*
4392   tries varients of chkpath
4393  */
4394 BOOL torture_chkpath_test(int dummy)
4395 {
4396         static struct cli_state *cli;
4397         int fnum;
4398         BOOL ret;
4399
4400         if (!torture_open_connection(&cli, 0)) {
4401                 return False;
4402         }
4403
4404         printf("starting chkpath test\n");
4405
4406         /* cleanup from an old run */
4407         cli_rmdir(cli, "\\chkpath.dir\\dir2");
4408         cli_unlink(cli, "\\chkpath.dir\\*");
4409         cli_rmdir(cli, "\\chkpath.dir");
4410
4411         if (!cli_mkdir(cli, "\\chkpath.dir")) {
4412                 printf("mkdir1 failed : %s\n", cli_errstr(cli));
4413                 return False;
4414         }
4415
4416         if (!cli_mkdir(cli, "\\chkpath.dir\\dir2")) {
4417                 printf("mkdir2 failed : %s\n", cli_errstr(cli));
4418                 return False;
4419         }
4420
4421         fnum = cli_open(cli, "\\chkpath.dir\\foo.txt", O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
4422         if (fnum == -1) {
4423                 printf("open1 failed (%s)\n", cli_errstr(cli));
4424                 return False;
4425         }
4426         cli_close(cli, fnum);
4427
4428         if (!cli_chkpath(cli, "\\chkpath.dir")) {
4429                 printf("chkpath1 failed: %s\n", cli_errstr(cli));
4430                 ret = False;
4431         }
4432
4433         if (!cli_chkpath(cli, "\\chkpath.dir\\dir2")) {
4434                 printf("chkpath2 failed: %s\n", cli_errstr(cli));
4435                 ret = False;
4436         }
4437
4438         if (!cli_chkpath(cli, "\\chkpath.dir\\foo.txt")) {
4439                 ret = check_error(__LINE__, cli, ERRDOS, ERRbadpath,
4440                                   NT_STATUS_NOT_A_DIRECTORY);
4441         } else {
4442                 printf("* chkpath on a file should fail\n");
4443                 ret = False;
4444         }
4445
4446         if (!cli_chkpath(cli, "\\chkpath.dir\\bar.txt")) {
4447                 ret = check_error(__LINE__, cli, ERRDOS, ERRbadfile,
4448                                   NT_STATUS_OBJECT_NAME_NOT_FOUND);
4449         } else {
4450                 printf("* chkpath on a non existant file should fail\n");
4451                 ret = False;
4452         }
4453
4454         if (!cli_chkpath(cli, "\\chkpath.dir\\dirxx\\bar.txt")) {
4455                 ret = check_error(__LINE__, cli, ERRDOS, ERRbadpath,
4456                                   NT_STATUS_OBJECT_PATH_NOT_FOUND);
4457         } else {
4458                 printf("* chkpath on a non existent component should fail\n");
4459                 ret = False;
4460         }
4461
4462         cli_rmdir(cli, "\\chkpath.dir\\dir2");
4463         cli_unlink(cli, "\\chkpath.dir\\*");
4464         cli_rmdir(cli, "\\chkpath.dir");
4465
4466         if (!torture_close_connection(cli)) {
4467                 return False;
4468         }
4469
4470         return ret;
4471 }
4472
4473 static BOOL run_eatest(int dummy)
4474 {
4475         static struct cli_state *cli;
4476         const char *fname = "\\eatest.txt";
4477         BOOL correct = True;
4478         int fnum, i;
4479         size_t num_eas;
4480         struct ea_struct *ea_list = NULL;
4481         TALLOC_CTX *mem_ctx = talloc_init("eatest");
4482
4483         printf("starting eatest\n");
4484
4485         if (!torture_open_connection(&cli, 0)) {
4486                 talloc_destroy(mem_ctx);
4487                 return False;
4488         }
4489
4490         cli_unlink(cli, fname);
4491         fnum = cli_nt_create_full(cli, fname, 0,
4492                                    FIRST_DESIRED_ACCESS, FILE_ATTRIBUTE_ARCHIVE,
4493                                    FILE_SHARE_NONE, FILE_OVERWRITE_IF,
4494                                    0x4044, 0);
4495
4496         if (fnum == -1) {
4497                 printf("open failed - %s\n", cli_errstr(cli));
4498                 talloc_destroy(mem_ctx);
4499                 return False;
4500         }
4501
4502         for (i = 0; i < 10; i++) {
4503                 fstring ea_name, ea_val;
4504
4505                 slprintf(ea_name, sizeof(ea_name), "EA_%d", i);
4506                 memset(ea_val, (char)i+1, i+1);
4507                 if (!cli_set_ea_fnum(cli, fnum, ea_name, ea_val, i+1)) {
4508                         printf("ea_set of name %s failed - %s\n", ea_name, cli_errstr(cli));
4509                         talloc_destroy(mem_ctx);
4510                         return False;
4511                 }
4512         }
4513
4514         cli_close(cli, fnum);
4515         for (i = 0; i < 10; i++) {
4516                 fstring ea_name, ea_val;
4517
4518                 slprintf(ea_name, sizeof(ea_name), "EA_%d", i+10);
4519                 memset(ea_val, (char)i+1, i+1);
4520                 if (!cli_set_ea_path(cli, fname, ea_name, ea_val, i+1)) {
4521                         printf("ea_set of name %s failed - %s\n", ea_name, cli_errstr(cli));
4522                         talloc_destroy(mem_ctx);
4523                         return False;
4524                 }
4525         }
4526
4527         if (!cli_get_ea_list_path(cli, fname, mem_ctx, &num_eas, &ea_list)) {
4528                 printf("ea_get list failed - %s\n", cli_errstr(cli));
4529                 correct = False;
4530         }
4531
4532         printf("num_eas = %d\n", (int)num_eas);
4533
4534         if (num_eas != 20) {
4535                 printf("Should be 20 EA's stored... failing.\n");
4536                 correct = False;
4537         }
4538
4539         for (i = 0; i < num_eas; i++) {
4540                 printf("%d: ea_name = %s. Val = ", i, ea_list[i].name);
4541                 dump_data(0, (char *)ea_list[i].value.data,
4542                           ea_list[i].value.length);
4543         }
4544
4545         /* Setting EA's to zero length deletes them. Test this */
4546         printf("Now deleting all EA's - case indepenent....\n");
4547
4548 #if 1
4549         cli_set_ea_path(cli, fname, "", "", 0);
4550 #else
4551         for (i = 0; i < 20; i++) {
4552                 fstring ea_name;
4553                 slprintf(ea_name, sizeof(ea_name), "ea_%d", i);
4554                 if (!cli_set_ea_path(cli, fname, ea_name, "", 0)) {
4555                         printf("ea_set of name %s failed - %s\n", ea_name, cli_errstr(cli));
4556                         talloc_destroy(mem_ctx);
4557                         return False;
4558                 }
4559         }
4560 #endif
4561
4562         if (!cli_get_ea_list_path(cli, fname, mem_ctx, &num_eas, &ea_list)) {
4563                 printf("ea_get list failed - %s\n", cli_errstr(cli));
4564                 correct = False;
4565         }
4566
4567         printf("num_eas = %d\n", (int)num_eas);
4568         for (i = 0; i < num_eas; i++) {
4569                 printf("%d: ea_name = %s. Val = ", i, ea_list[i].name);
4570                 dump_data(0, (char *)ea_list[i].value.data,
4571                           ea_list[i].value.length);
4572         }
4573
4574         if (num_eas != 0) {
4575                 printf("deleting EA's failed.\n");
4576                 correct = False;
4577         }
4578
4579         /* Try and delete a non existant EA. */
4580         if (!cli_set_ea_path(cli, fname, "foo", "", 0)) {
4581                 printf("deleting non-existant EA 'foo' should succeed. %s\n", cli_errstr(cli));
4582                 correct = False;
4583         }
4584
4585         talloc_destroy(mem_ctx);
4586         if (!torture_close_connection(cli)) {
4587                 correct = False;
4588         }
4589
4590         return correct;
4591 }
4592
4593 static BOOL run_dirtest1(int dummy)
4594 {
4595         int i;
4596         static struct cli_state *cli;
4597         int fnum, num_seen;
4598         BOOL correct = True;
4599
4600         printf("starting directory test\n");
4601
4602         if (!torture_open_connection(&cli, 0)) {
4603                 return False;
4604         }
4605
4606         cli_sockopt(cli, sockops);
4607
4608         cli_list(cli, "\\LISTDIR\\*", 0, del_fn, cli);
4609         cli_list(cli, "\\LISTDIR\\*", aDIR, del_fn, cli);
4610         cli_rmdir(cli, "\\LISTDIR");
4611         cli_mkdir(cli, "\\LISTDIR");
4612
4613         /* Create 1000 files and 1000 directories. */
4614         for (i=0;i<1000;i++) {
4615                 fstring fname;
4616                 slprintf(fname, sizeof(fname), "\\LISTDIR\\f%d", i);
4617                 fnum = cli_nt_create_full(cli, fname, 0, GENERIC_ALL_ACCESS, FILE_ATTRIBUTE_ARCHIVE,
4618                                    FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OVERWRITE_IF, 0, 0);
4619                 if (fnum == -1) {
4620                         fprintf(stderr,"Failed to open %s\n", fname);
4621                         return False;
4622                 }
4623                 cli_close(cli, fnum);
4624         }
4625         for (i=0;i<1000;i++) {
4626                 fstring fname;
4627                 slprintf(fname, sizeof(fname), "\\LISTDIR\\d%d", i);
4628                 if (!cli_mkdir(cli, fname)) {
4629                         fprintf(stderr,"Failed to open %s\n", fname);
4630                         return False;
4631                 }
4632         }
4633
4634         /* Now ensure that doing an old list sees both files and directories. */
4635         num_seen = cli_list_old(cli, "\\LISTDIR\\*", aDIR, list_fn, NULL);
4636         printf("num_seen = %d\n", num_seen );
4637         /* We should see 100 files + 1000 directories + . and .. */
4638         if (num_seen != 2002)
4639                 correct = False;
4640
4641         /* Ensure if we have the "must have" bits we only see the
4642          * relevent entries.
4643          */
4644         num_seen = cli_list_old(cli, "\\LISTDIR\\*", (aDIR<<8)|aDIR, list_fn, NULL);
4645         printf("num_seen = %d\n", num_seen );
4646         if (num_seen != 1002)
4647                 correct = False;
4648
4649         num_seen = cli_list_old(cli, "\\LISTDIR\\*", (aARCH<<8)|aDIR, list_fn, NULL);
4650         printf("num_seen = %d\n", num_seen );
4651         if (num_seen != 1000)
4652                 correct = False;
4653
4654         /* Delete everything. */
4655         cli_list(cli, "\\LISTDIR\\*", 0, del_fn, cli);
4656         cli_list(cli, "\\LISTDIR\\*", aDIR, del_fn, cli);
4657         cli_rmdir(cli, "\\LISTDIR");
4658
4659 #if 0
4660         printf("Matched %d\n", cli_list(cli, "a*.*", 0, list_fn, NULL));
4661         printf("Matched %d\n", cli_list(cli, "b*.*", 0, list_fn, NULL));
4662         printf("Matched %d\n", cli_list(cli, "xyzabc", 0, list_fn, NULL));
4663 #endif
4664
4665         if (!torture_close_connection(cli)) {
4666                 correct = False;
4667         }
4668
4669         printf("finished dirtest1\n");
4670
4671         return correct;
4672 }
4673
4674 static BOOL run_error_map_extract(int dummy) {
4675
4676         static struct cli_state *c_dos;
4677         static struct cli_state *c_nt;
4678
4679         uint32 error;
4680
4681         uint32 flgs2, errnum;
4682         uint8 errclass;
4683
4684         NTSTATUS nt_status;
4685
4686         fstring user;
4687
4688         /* NT-Error connection */
4689
4690         if (!(c_nt = open_nbt_connection())) {
4691                 return False;
4692         }
4693
4694         c_nt->use_spnego = False;
4695
4696         if (!cli_negprot(c_nt)) {
4697                 printf("%s rejected the NT-error negprot (%s)\n",host, cli_errstr(c_nt));
4698                 cli_shutdown(c_nt);
4699                 return False;
4700         }
4701
4702         if (!NT_STATUS_IS_OK(cli_session_setup(c_nt, "", "", 0, "", 0,
4703                                                workgroup))) {
4704                 printf("%s rejected the NT-error initial session setup (%s)\n",host, cli_errstr(c_nt));
4705                 return False;
4706         }
4707
4708         /* DOS-Error connection */
4709
4710         if (!(c_dos = open_nbt_connection())) {
4711                 return False;
4712         }
4713
4714         c_dos->use_spnego = False;
4715         c_dos->force_dos_errors = True;
4716
4717         if (!cli_negprot(c_dos)) {
4718                 printf("%s rejected the DOS-error negprot (%s)\n",host, cli_errstr(c_dos));
4719                 cli_shutdown(c_dos);
4720                 return False;
4721         }
4722
4723         if (!NT_STATUS_IS_OK(cli_session_setup(c_dos, "", "", 0, "", 0,
4724                                                workgroup))) {
4725                 printf("%s rejected the DOS-error initial session setup (%s)\n",host, cli_errstr(c_dos));
4726                 return False;
4727         }
4728
4729         for (error=(0xc0000000 | 0x1); error < (0xc0000000| 0xFFF); error++) {
4730                 fstr_sprintf(user, "%X", error);
4731
4732                 if (NT_STATUS_IS_OK(cli_session_setup(c_nt, user,
4733                                                       password, strlen(password),
4734                                                       password, strlen(password),
4735                                                       workgroup))) {
4736                         printf("/** Session setup succeeded.  This shouldn't happen...*/\n");
4737                 }
4738
4739                 flgs2 = SVAL(c_nt->inbuf,smb_flg2);
4740
4741                 /* Case #1: 32-bit NT errors */
4742                 if (flgs2 & FLAGS2_32_BIT_ERROR_CODES) {
4743                         nt_status = NT_STATUS(IVAL(c_nt->inbuf,smb_rcls));
4744                 } else {
4745                         printf("/** Dos error on NT connection! (%s) */\n",
4746                                cli_errstr(c_nt));
4747                         nt_status = NT_STATUS(0xc0000000);
4748                 }
4749
4750                 if (NT_STATUS_IS_OK(cli_session_setup(c_dos, user,
4751                                                       password, strlen(password),
4752                                                       password, strlen(password),
4753                                                       workgroup))) {
4754                         printf("/** Session setup succeeded.  This shouldn't happen...*/\n");
4755                 }
4756                 flgs2 = SVAL(c_dos->inbuf,smb_flg2), errnum;
4757
4758                 /* Case #1: 32-bit NT errors */
4759                 if (flgs2 & FLAGS2_32_BIT_ERROR_CODES) {
4760                         printf("/** NT error on DOS connection! (%s) */\n",
4761                                cli_errstr(c_nt));
4762                         errnum = errclass = 0;
4763                 } else {
4764                         cli_dos_error(c_dos, &errclass, &errnum);
4765                 }
4766
4767                 if (NT_STATUS_V(nt_status) != error) {
4768                         printf("/*\t{ This NT error code was 'sqashed'\n\t from %s to %s \n\t during the session setup }\n*/\n",
4769                                get_nt_error_c_code(NT_STATUS(error)),
4770                                get_nt_error_c_code(nt_status));
4771                 }
4772
4773                 printf("\t{%s,\t%s,\t%s},\n",
4774                        smb_dos_err_class(errclass),
4775                        smb_dos_err_name(errclass, errnum),
4776                        get_nt_error_c_code(NT_STATUS(error)));
4777         }
4778         return True;
4779 }
4780
4781 static BOOL run_local_substitute(int dummy)
4782 {
4783         TALLOC_CTX *mem_ctx;
4784         int diff = 0;
4785
4786         if ((mem_ctx = talloc_init("run_local_subst")) == NULL) {
4787                 printf("talloc_init failed\n");
4788                 return False;
4789         }
4790
4791         diff |= strcmp(talloc_sub_specified(mem_ctx, "%U", "bla", "", -1, -1),
4792                        "bla");
4793         diff |= strcmp(talloc_sub_specified(mem_ctx, "%u%U", "bla", "", -1, -1),
4794                        "blabla");
4795         diff |= strcmp(talloc_sub_specified(mem_ctx, "%g", "", "", -1, -1),
4796                        "NO_GROUP");
4797         diff |= strcmp(talloc_sub_specified(mem_ctx, "%G", "", "", -1, -1),
4798                        "NO_GROUP");
4799         diff |= strcmp(talloc_sub_specified(mem_ctx, "%g", "", "", -1, 0),
4800                        gidtoname(0));
4801         diff |= strcmp(talloc_sub_specified(mem_ctx, "%G", "", "", -1, 0),
4802                        gidtoname(0));
4803         diff |= strcmp(talloc_sub_specified(mem_ctx, "%D%u", "u", "dom", -1, 0),
4804                        "domu");
4805         diff |= strcmp(talloc_sub_specified(mem_ctx, "%i %I", "", "", -1, -1),
4806                        "0.0.0.0 0.0.0.0");
4807
4808         /* Different captialization rules in sub_basic... */
4809
4810         diff |= strcmp(talloc_sub_basic(mem_ctx, "BLA", "dom", "%U%D"),
4811                        "blaDOM");
4812
4813         TALLOC_FREE(mem_ctx);
4814         return (diff == 0);
4815 }
4816
4817 static BOOL run_local_gencache(int dummy)
4818 {
4819         char *val;
4820         time_t tm;
4821
4822         if (!gencache_init()) {
4823                 d_printf("%s: gencache_init() failed\n", __location__);
4824                 return False;
4825         }
4826
4827         if (!gencache_set("foo", "bar", time(NULL) + 1000)) {
4828                 d_printf("%s: gencache_set() failed\n", __location__);
4829                 return False;
4830         }
4831
4832         if (!gencache_get("foo", &val, &tm)) {
4833                 d_printf("%s: gencache_get() failed\n", __location__);
4834                 return False;
4835         }
4836
4837         if (strcmp(val, "bar") != 0) {
4838                 d_printf("%s: gencache_get() returned %s, expected %s\n",
4839                          __location__, val, "bar");
4840                 SAFE_FREE(val);
4841                 return False;
4842         }
4843
4844         SAFE_FREE(val);
4845
4846         if (!gencache_del("foo")) {
4847                 d_printf("%s: gencache_del() failed\n", __location__);
4848                 return False;
4849         }
4850         if (gencache_del("foo")) {
4851                 d_printf("%s: second gencache_del() succeeded\n",
4852                          __location__);
4853                 return False;
4854         }
4855
4856         if (gencache_get("foo", &val, &tm)) {
4857                 d_printf("%s: gencache_get() on deleted entry "
4858                          "succeeded\n", __location__);
4859                 return False;
4860         }
4861
4862         if (!gencache_shutdown()) {
4863                 d_printf("%s: gencache_shutdown() failed\n", __location__);
4864                 return False;
4865         }
4866
4867         if (gencache_shutdown()) {
4868                 d_printf("%s: second gencache_shutdown() succeeded\n",
4869                          __location__);
4870                 return False;
4871         }
4872
4873         return True;
4874 }
4875
4876 static double create_procs(BOOL (*fn)(int), BOOL *result)
4877 {
4878         int i, status;
4879         volatile pid_t *child_status;
4880         volatile BOOL *child_status_out;
4881         int synccount;
4882         int tries = 8;
4883
4884         synccount = 0;
4885
4886         child_status = (volatile pid_t *)shm_setup(sizeof(pid_t)*nprocs);
4887         if (!child_status) {
4888                 printf("Failed to setup shared memory\n");
4889                 return -1;
4890         }
4891
4892         child_status_out = (volatile BOOL *)shm_setup(sizeof(BOOL)*nprocs);
4893         if (!child_status_out) {
4894                 printf("Failed to setup result status shared memory\n");
4895                 return -1;
4896         }
4897
4898         for (i = 0; i < nprocs; i++) {
4899                 child_status[i] = 0;
4900                 child_status_out[i] = True;
4901         }
4902
4903         start_timer();
4904
4905         for (i=0;i<nprocs;i++) {
4906                 procnum = i;
4907                 if (fork() == 0) {
4908                         pid_t mypid = getpid();
4909                         sys_srandom(((int)mypid) ^ ((int)time(NULL)));
4910
4911                         slprintf(myname,sizeof(myname),"CLIENT%d", i);
4912
4913                         while (1) {
4914                                 if (torture_open_connection(&current_cli, i)) break;
4915                                 if (tries-- == 0) {
4916                                         printf("pid %d failed to start\n", (int)getpid());
4917                                         _exit(1);
4918                                 }
4919                                 smb_msleep(10);
4920                         }
4921
4922                         child_status[i] = getpid();
4923
4924                         while (child_status[i] && end_timer() < 5) smb_msleep(2);
4925
4926                         child_status_out[i] = fn(i);
4927                         _exit(0);
4928                 }
4929         }
4930
4931         do {
4932                 synccount = 0;
4933                 for (i=0;i<nprocs;i++) {
4934                         if (child_status[i]) synccount++;
4935                 }
4936                 if (synccount == nprocs) break;
4937                 smb_msleep(10);
4938         } while (end_timer() < 30);
4939
4940         if (synccount != nprocs) {
4941                 printf("FAILED TO START %d CLIENTS (started %d)\n", nprocs, synccount);
4942                 *result = False;
4943                 return end_timer();
4944         }
4945
4946         /* start the client load */
4947         start_timer();
4948
4949         for (i=0;i<nprocs;i++) {
4950                 child_status[i] = 0;
4951         }
4952
4953         printf("%d clients started\n", nprocs);
4954
4955         for (i=0;i<nprocs;i++) {
4956                 while (waitpid(0, &status, 0) == -1 && errno == EINTR) /* noop */ ;
4957         }
4958
4959         printf("\n");
4960
4961         for (i=0;i<nprocs;i++) {
4962                 if (!child_status_out[i]) {
4963                         *result = False;
4964                 }
4965         }
4966         return end_timer();
4967 }
4968
4969 #define FLAG_MULTIPROC 1
4970
4971 static struct {
4972         const char *name;
4973         BOOL (*fn)(int);
4974         unsigned flags;
4975 } torture_ops[] = {
4976         {"FDPASS", run_fdpasstest, 0},
4977         {"LOCK1",  run_locktest1,  0},
4978         {"LOCK2",  run_locktest2,  0},
4979         {"LOCK3",  run_locktest3,  0},
4980         {"LOCK4",  run_locktest4,  0},
4981         {"LOCK5",  run_locktest5,  0},
4982         {"LOCK6",  run_locktest6,  0},
4983         {"LOCK7",  run_locktest7,  0},
4984         {"UNLINK", run_unlinktest, 0},
4985         {"BROWSE", run_browsetest, 0},
4986         {"ATTR",   run_attrtest,   0},
4987         {"TRANS2", run_trans2test, 0},
4988         {"MAXFID", run_maxfidtest, FLAG_MULTIPROC},
4989         {"TORTURE",run_torture,    FLAG_MULTIPROC},
4990         {"RANDOMIPC", run_randomipc, 0},
4991         {"NEGNOWAIT", run_negprot_nowait, 0},
4992         {"NBENCH",  run_nbench, 0},
4993         {"OPLOCK1",  run_oplock1, 0},
4994         {"OPLOCK2",  run_oplock2, 0},
4995         {"OPLOCK3",  run_oplock3, 0},
4996         {"DIR",  run_dirtest, 0},
4997         {"DIR1",  run_dirtest1, 0},
4998         {"DENY1",  torture_denytest1, 0},
4999         {"DENY2",  torture_denytest2, 0},
5000         {"TCON",  run_tcon_test, 0},
5001         {"TCONDEV",  run_tcon_devtype_test, 0},
5002         {"RW1",  run_readwritetest, 0},
5003         {"RW2",  run_readwritemulti, FLAG_MULTIPROC},
5004         {"RW3",  run_readwritelarge, 0},
5005         {"OPEN", run_opentest, 0},
5006 #if 1
5007         {"OPENATTR", run_openattrtest, 0},
5008 #endif
5009         {"XCOPY", run_xcopy, 0},
5010         {"RENAME", run_rename, 0},
5011         {"DELETE", run_deletetest, 0},
5012         {"PROPERTIES", run_properties, 0},
5013         {"MANGLE", torture_mangle, 0},
5014         {"W2K", run_w2ktest, 0},
5015         {"TRANS2SCAN", torture_trans2_scan, 0},
5016         {"NTTRANSSCAN", torture_nttrans_scan, 0},
5017         {"UTABLE", torture_utable, 0},
5018         {"CASETABLE", torture_casetable, 0},
5019         {"ERRMAPEXTRACT", run_error_map_extract, 0},
5020         {"PIPE_NUMBER", run_pipe_number, 0},
5021         {"TCON2",  run_tcon2_test, 0},
5022         {"IOCTL",  torture_ioctl_test, 0},
5023         {"CHKPATH",  torture_chkpath_test, 0},
5024         {"FDSESS", run_fdsesstest, 0},
5025         { "EATEST", run_eatest, 0},
5026         { "LOCAL-SUBSTITUTE", run_local_substitute, 0},
5027         { "LOCAL-GENCACHE", run_local_gencache, 0},
5028         {NULL, NULL, 0}};
5029
5030
5031
5032 /****************************************************************************
5033 run a specified test or "ALL"
5034 ****************************************************************************/
5035 static BOOL run_test(const char *name)
5036 {
5037         BOOL ret = True;
5038         BOOL result = True;
5039         BOOL found = False;
5040         int i;
5041         double t;
5042         if (strequal(name,"ALL")) {
5043                 for (i=0;torture_ops[i].name;i++) {
5044                         run_test(torture_ops[i].name);
5045                 }
5046                 found = True;
5047         }
5048
5049         for (i=0;torture_ops[i].name;i++) {
5050                 fstr_sprintf(randomfname, "\\XX%x",
5051                          (unsigned)random());
5052
5053                 if (strequal(name, torture_ops[i].name)) {
5054                         found = True;
5055                         printf("Running %s\n", name);
5056                         if (torture_ops[i].flags & FLAG_MULTIPROC) {
5057                                 t = create_procs(torture_ops[i].fn, &result);
5058                                 if (!result) {
5059                                         ret = False;
5060                                         printf("TEST %s FAILED!\n", name);
5061                                 }
5062
5063                         } else {
5064                                 start_timer();
5065                                 if (!torture_ops[i].fn(0)) {
5066                                         ret = False;
5067                                         printf("TEST %s FAILED!\n", name);
5068                                 }
5069                                 t = end_timer();
5070                         }
5071                         printf("%s took %g secs\n\n", name, t);
5072                 }
5073         }
5074
5075         if (!found) {
5076                 printf("Did not find a test named %s\n", name);
5077                 ret = False;
5078         }
5079
5080         return ret;
5081 }
5082
5083
5084 static void usage(void)
5085 {
5086         int i;
5087
5088         printf("WARNING samba4 test suite is much more complete nowadays.\n");
5089         printf("Please use samba4 torture.\n\n");
5090
5091         printf("Usage: smbtorture //server/share <options> TEST1 TEST2 ...\n");
5092
5093         printf("\t-d debuglevel\n");
5094         printf("\t-U user%%pass\n");
5095         printf("\t-k               use kerberos\n");
5096         printf("\t-N numprocs\n");
5097         printf("\t-n my_netbios_name\n");
5098         printf("\t-W workgroup\n");
5099         printf("\t-o num_operations\n");
5100         printf("\t-O socket_options\n");
5101         printf("\t-m maximum protocol\n");
5102         printf("\t-L use oplocks\n");
5103         printf("\t-c CLIENT.TXT   specify client load file for NBENCH\n");
5104         printf("\t-A showall\n");
5105         printf("\t-p port\n");
5106         printf("\t-s seed\n");
5107         printf("\t-b unclist_filename   specify multiple shares for multiple connections\n");
5108         printf("\n\n");
5109
5110         printf("tests are:");
5111         for (i=0;torture_ops[i].name;i++) {
5112                 printf(" %s", torture_ops[i].name);
5113         }
5114         printf("\n");
5115
5116         printf("default test is ALL\n");
5117
5118         exit(1);
5119 }
5120
5121 /****************************************************************************
5122   main program
5123 ****************************************************************************/
5124  int main(int argc,char *argv[])
5125 {
5126         int opt, i;
5127         char *p;
5128         int gotuser = 0;
5129         int gotpass = 0;
5130         BOOL correct = True;
5131
5132         dbf = x_stdout;
5133
5134 #ifdef HAVE_SETBUFFER
5135         setbuffer(stdout, NULL, 0);
5136 #endif
5137
5138         load_case_tables();
5139
5140         lp_load(dyn_CONFIGFILE,True,False,False,True);
5141         load_interfaces();
5142
5143         if (argc < 2) {
5144                 usage();
5145         }
5146
5147         for(p = argv[1]; *p; p++)
5148           if(*p == '\\')
5149             *p = '/';
5150
5151         if (strncmp(argv[1], "//", 2)) {
5152                 usage();
5153         }
5154
5155         fstrcpy(host, &argv[1][2]);
5156         p = strchr_m(&host[2],'/');
5157         if (!p) {
5158                 usage();
5159         }
5160         *p = 0;
5161         fstrcpy(share, p+1);
5162
5163         get_myname(myname);
5164
5165         if (*username == 0 && getenv("LOGNAME")) {
5166           fstrcpy(username,getenv("LOGNAME"));
5167         }
5168
5169         argc--;
5170         argv++;
5171
5172         srandom(time(NULL));
5173
5174         fstrcpy(workgroup, lp_workgroup());
5175
5176         while ((opt = getopt(argc, argv, "p:hW:U:n:N:O:o:m:Ld:Ac:ks:b:")) != EOF) {
5177                 switch (opt) {
5178                 case 'p':
5179                         port_to_use = atoi(optarg);
5180                         break;
5181                 case 's':
5182                         srandom(atoi(optarg));
5183                         break;
5184                 case 'W':
5185                         fstrcpy(workgroup,optarg);
5186                         break;
5187                 case 'm':
5188                         max_protocol = interpret_protocol(optarg, max_protocol);
5189                         break;
5190                 case 'N':
5191                         nprocs = atoi(optarg);
5192                         break;
5193                 case 'o':
5194                         torture_numops = atoi(optarg);
5195                         break;
5196                 case 'd':
5197                         DEBUGLEVEL = atoi(optarg);
5198                         break;
5199                 case 'O':
5200                         sockops = optarg;
5201                         break;
5202                 case 'L':
5203                         use_oplocks = True;
5204                         break;
5205                 case 'A':
5206                         torture_showall = True;
5207                         break;
5208                 case 'n':
5209                         fstrcpy(myname, optarg);
5210                         break;
5211                 case 'c':
5212                         client_txt = optarg;
5213                         break;
5214                 case 'k':
5215 #ifdef HAVE_KRB5
5216                         use_kerberos = True;
5217 #else
5218                         d_printf("No kerberos support compiled in\n");
5219                         exit(1);
5220 #endif
5221                         break;
5222                 case 'U':
5223                         gotuser = 1;
5224                         fstrcpy(username,optarg);
5225                         p = strchr_m(username,'%');
5226                         if (p) {
5227                                 *p = 0;
5228                                 fstrcpy(password, p+1);
5229                                 gotpass = 1;
5230                         }
5231                         break;
5232                 case 'b':
5233                         fstrcpy(multishare_conn_fname, optarg);
5234                         use_multishare_conn = True;
5235                         break;
5236                 default:
5237                         printf("Unknown option %c (%d)\n", (char)opt, opt);
5238                         usage();
5239                 }
5240         }
5241
5242         if(use_kerberos && !gotuser) gotpass = True;
5243
5244         while (!gotpass) {
5245                 p = getpass("Password:");
5246                 if (p) {
5247                         fstrcpy(password, p);
5248                         gotpass = 1;
5249                 }
5250         }
5251
5252         printf("host=%s share=%s user=%s myname=%s\n",
5253                host, share, username, myname);
5254
5255         if (argc == optind) {
5256                 correct = run_test("ALL");
5257         } else {
5258                 for (i=optind;i<argc;i++) {
5259                         if (!run_test(argv[i])) {
5260                                 correct = False;
5261                         }
5262                 }
5263         }
5264
5265         if (correct) {
5266                 return(0);
5267         } else {
5268                 return(1);
5269         }
5270 }