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