source3/torture/torture.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    SMB torture tester
   4    Copyright (C) Andrew Tridgell 1997-1998
   5    Copyright (C) Jeremy Allison 2009
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19 */
  20
  21 #include "includes.h"
  22 #include "system/shmem.h"
  23 #include "wbc_async.h"
  24 #include "torture/proto.h"
  25 #include "libcli/security/security.h"
  26 #include "tldap.h"
  27 #include "tldap_util.h"
  28 #include "../librpc/gen_ndr/svcctl.h"
  29 #include "memcache.h"
  30 #include "nsswitch/winbind_client.h"
  31 #include "dbwrap/dbwrap.h"
  32 #include "dbwrap/dbwrap_open.h"
  33 #include "talloc_dict.h"
  34 #include "async_smb.h"
  35 #include "libsmb/libsmb.h"
  36 #include "libsmb/clirap.h"
  37 #include "trans2.h"
  38 #include "libsmb/nmblib.h"
  39 #include "../lib/util/tevent_ntstatus.h"
  40 #include "util_tdb.h"
  41 #include "libsmb/read_smb.h"
  42
  43 extern char *optarg;
  44 extern int optind;
  45
  46 fstring host, workgroup, share, password, username, myname;
  47 static int max_protocol = PROTOCOL_NT1;
  48 static const char *sockops="TCP_NODELAY";
  49 static int nprocs=1;
  50 static int port_to_use=0;
  51 int torture_numops=100;
  52 int torture_blocksize=1024*1024;
  53 static int procnum; /* records process count number when forking */
  54 static struct cli_state *current_cli;
  55 static fstring randomfname;
  56 static bool use_oplocks;
  57 static bool use_level_II_oplocks;
  58 static const char *client_txt = "client_oplocks.txt";
  59 static bool use_kerberos;
  60 static bool force_dos_errors;
  61 static fstring multishare_conn_fname;
  62 static bool use_multishare_conn = False;
  63 static bool do_encrypt;
  64 static const char *local_path = NULL;
  65 static int signing_state = Undefined;
  66 char *test_filename;
  67
  68 bool torture_showall = False;
  69
  70 static double create_procs(bool (*fn)(int), bool *result);
  71
  72
  73 /* return a pointer to a anonymous shared memory segment of size "size"
  74    which will persist across fork() but will disappear when all processes
  75    exit
  76
  77    The memory is not zeroed
  78
  79    This function uses system5 shared memory. It takes advantage of a property
  80    that the memory is not destroyed if it is attached when the id is removed
  81    */
  82 void *shm_setup(int size)
  83 {
  84         int shmid;
  85         void *ret;
  86
  87 #ifdef __QNXNTO__
  88         shmid = shm_open("private", O_RDWR | O_CREAT | O_EXCL, S_IRUSR | S_IWUSR);
  89         if (shmid == -1) {
  90                 printf("can't get shared memory\n");
  91                 exit(1);
  92         }
  93         shm_unlink("private");
  94         if (ftruncate(shmid, size) == -1) {
  95                 printf("can't set shared memory size\n");
  96                 exit(1);
  97         }
  98         ret = mmap(0, size, PROT_READ | PROT_WRITE, MAP_SHARED, shmid, 0);
  99         if (ret == MAP_FAILED) {
 100                 printf("can't map shared memory\n");
 101                 exit(1);
 102         }
 103 #else
 104         shmid = shmget(IPC_PRIVATE, size, S_IRUSR | S_IWUSR);
 105         if (shmid == -1) {
 106                 printf("can't get shared memory\n");
 107                 exit(1);
 108         }
 109         ret = (void *)shmat(shmid, 0, 0);
 110         if (!ret || ret == (void *)-1) {
 111                 printf("can't attach to shared memory\n");
 112                 return NULL;
 113         }
 114         /* the following releases the ipc, but note that this process
 115            and all its children will still have access to the memory, its
 116            just that the shmid is no longer valid for other shm calls. This
 117            means we don't leave behind lots of shm segments after we exit
 118
 119            See Stevens "advanced programming in unix env" for details
 120            */
 121         shmctl(shmid, IPC_RMID, 0);
 122 #endif
 123
 124         return ret;
 125 }
 126
 127 /********************************************************************
 128  Ensure a connection is encrypted.
 129 ********************************************************************/
 130
 131 static bool force_cli_encryption(struct cli_state *c,
 132                         const char *sharename)
 133 {
 134         uint16 major, minor;
 135         uint32 caplow, caphigh;
 136         NTSTATUS status;
 137
 138         if (!SERVER_HAS_UNIX_CIFS(c)) {
 139                 d_printf("Encryption required and "
 140                         "server that doesn't support "
 141                         "UNIX extensions - failing connect\n");
 142                         return false;
 143         }
 144
 145         status = cli_unix_extensions_version(c, &major, &minor, &caplow,
 146                                              &caphigh);
 147         if (!NT_STATUS_IS_OK(status)) {
 148                 d_printf("Encryption required and "
 149                         "can't get UNIX CIFS extensions "
 150                         "version from server: %s\n", nt_errstr(status));
 151                 return false;
 152         }
 153
 154         if (!(caplow & CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP)) {
 155                 d_printf("Encryption required and "
 156                         "share %s doesn't support "
 157                         "encryption.\n", sharename);
 158                 return false;
 159         }
 160
 161         if (c->use_kerberos) {
 162                 status = cli_gss_smb_encryption_start(c);
 163         } else {
 164                 status = cli_raw_ntlm_smb_encryption_start(c,
 165                                                 username,
 166                                                 password,
 167                                                 workgroup);
 168         }
 169
 170         if (!NT_STATUS_IS_OK(status)) {
 171                 d_printf("Encryption required and "
 172                         "setup failed with error %s.\n",
 173                         nt_errstr(status));
 174                 return false;
 175         }
 176
 177         return true;
 178 }
 179
 180
 181 static struct cli_state *open_nbt_connection(void)
 182 {
 183         struct cli_state *c;
 184         NTSTATUS status;
 185         int flags = 0;
 186
 187         if (use_oplocks) {
 188                 flags |= CLI_FULL_CONNECTION_OPLOCKS;
 189         }
 190
 191         if (use_level_II_oplocks) {
 192                 flags |= CLI_FULL_CONNECTION_LEVEL_II_OPLOCKS;
 193         }
 194
 195         if (use_kerberos) {
 196                 flags |= CLI_FULL_CONNECTION_USE_KERBEROS;
 197         }
 198
 199         if (force_dos_errors) {
 200                 flags |= CLI_FULL_CONNECTION_FORCE_DOS_ERRORS;
 201         }
 202
 203         status = cli_connect_nb(host, NULL, port_to_use, 0x20, myname,
 204                                 signing_state, flags, &c);
 205         if (!NT_STATUS_IS_OK(status)) {
 206                 printf("Failed to connect with %s. Error %s\n", host, nt_errstr(status) );
 207                 return NULL;
 208         }
 209
 210         cli_set_timeout(c, 120000); /* set a really long timeout (2 minutes) */
 211
 212         return c;
 213 }
 214
 215 /****************************************************************************
 216  Send a corrupt session request. See rfc1002.txt 4.3 and 4.3.2.
 217 ****************************************************************************/
 218
 219 static bool cli_bad_session_request(int fd,
 220                          struct nmb_name *calling, struct nmb_name *called)
 221 {
 222         TALLOC_CTX *frame;
 223         uint8_t len_buf[4];
 224         struct iovec iov[3];
 225         ssize_t len;
 226         uint8_t *inbuf;
 227         int err;
 228         bool ret = false;
 229         uint8_t message_type;
 230         uint8_t error;
 231
 232         frame = talloc_stackframe();
 233
 234         iov[0].iov_base = len_buf;
 235         iov[0].iov_len  = sizeof(len_buf);
 236
 237         /* put in the destination name */
 238
 239         iov[1].iov_base = name_mangle(talloc_tos(), called->name,
 240                                       called->name_type);
 241         if (iov[1].iov_base == NULL) {
 242                 goto fail;
 243         }
 244         iov[1].iov_len = name_len((unsigned char *)iov[1].iov_base,
 245                                   talloc_get_size(iov[1].iov_base));
 246
 247         /* and my name */
 248
 249         iov[2].iov_base = name_mangle(talloc_tos(), calling->name,
 250                                       calling->name_type);
 251         if (iov[2].iov_base == NULL) {
 252                 goto fail;
 253         }
 254         iov[2].iov_len = name_len((unsigned char *)iov[2].iov_base,
 255                                   talloc_get_size(iov[2].iov_base));
 256
 257         /* Deliberately corrupt the name len (first byte) */
 258         *((uint8_t *)iov[2].iov_base) = 100;
 259
 260         /* send a session request (RFC 1002) */
 261         /* setup the packet length
 262          * Remove four bytes from the length count, since the length
 263          * field in the NBT Session Service header counts the number
 264          * of bytes which follow.  The cli_send_smb() function knows
 265          * about this and accounts for those four bytes.
 266          * CRH.
 267          */
 268
 269         _smb_setlen(len_buf, iov[1].iov_len + iov[2].iov_len);
 270         SCVAL(len_buf,0,0x81);
 271
 272         len = write_data_iov(fd, iov, 3);
 273         if (len == -1) {
 274                 goto fail;
 275         }
 276         len = read_smb(fd, talloc_tos(), &inbuf, &err);
 277         if (len == -1) {
 278                 errno = err;
 279                 goto fail;
 280         }
 281
 282         message_type = CVAL(inbuf, 0);
 283         if (message_type != 0x83) {
 284                 d_fprintf(stderr, "Expected msg type 0x83, got 0x%2.2x\n",
 285                           message_type);
 286                 goto fail;
 287         }
 288
 289         if (smb_len(inbuf) != 1) {
 290                 d_fprintf(stderr, "Expected smb_len 1, got %d\n",
 291                           (int)smb_len(inbuf));
 292                 goto fail;
 293         }
 294
 295         error = CVAL(inbuf, 4);
 296         if (error !=  0x82) {
 297                 d_fprintf(stderr, "Expected error 0x82, got %d\n",
 298                           (int)error);
 299                 goto fail;
 300         }
 301
 302         ret = true;
 303 fail:
 304         TALLOC_FREE(frame);
 305         return ret;
 306 }
 307
 308 /* Insert a NULL at the first separator of the given path and return a pointer
 309  * to the remainder of the string.
 310  */
 311 static char *
 312 terminate_path_at_separator(char * path)
 313 {
 314         char * p;
 315
 316         if (!path) {
 317                 return NULL;
 318         }
 319
 320         if ((p = strchr_m(path, '/'))) {
 321                 *p = '\0';
 322                 return p + 1;
 323         }
 324
 325         if ((p = strchr_m(path, '\\'))) {
 326                 *p = '\0';
 327                 return p + 1;
 328         }
 329
 330         /* No separator. */
 331         return NULL;
 332 }
 333
 334 /*
 335   parse a //server/share type UNC name
 336 */
 337 bool smbcli_parse_unc(const char *unc_name, TALLOC_CTX *mem_ctx,
 338                       char **hostname, char **sharename)
 339 {
 340         char *p;
 341
 342         *hostname = *sharename = NULL;
 343
 344         if (strncmp(unc_name, "\\\\", 2) &&
 345             strncmp(unc_name, "//", 2)) {
 346                 return False;
 347         }
 348
 349         *hostname = talloc_strdup(mem_ctx, &unc_name[2]);
 350         p = terminate_path_at_separator(*hostname);
 351
 352         if (p && *p) {
 353                 *sharename = talloc_strdup(mem_ctx, p);
 354                 terminate_path_at_separator(*sharename);
 355         }
 356
 357         if (*hostname && *sharename) {
 358                 return True;
 359         }
 360
 361         TALLOC_FREE(*hostname);
 362         TALLOC_FREE(*sharename);
 363         return False;
 364 }
 365
 366 static bool torture_open_connection_share(struct cli_state **c,
 367                                    const char *hostname,
 368                                    const char *sharename)
 369 {
 370         int flags = 0;
 371         NTSTATUS status;
 372
 373         if (use_kerberos)
 374                 flags |= CLI_FULL_CONNECTION_USE_KERBEROS;
 375         if (use_oplocks)
 376                 flags |= CLI_FULL_CONNECTION_OPLOCKS;
 377         if (use_level_II_oplocks)
 378                 flags |= CLI_FULL_CONNECTION_LEVEL_II_OPLOCKS;
 379
 380         status = cli_full_connection(c, myname,
 381                                      hostname, NULL, port_to_use,
 382                                      sharename, "?????",
 383                                      username, workgroup,
 384                                      password, flags, signing_state);
 385         if (!NT_STATUS_IS_OK(status)) {
 386                 printf("failed to open share connection: //%s/%s port:%d - %s\n",
 387                         hostname, sharename, port_to_use, nt_errstr(status));
 388                 return False;
 389         }
 390
 391         cli_set_timeout(*c, 120000); /* set a really long timeout (2 minutes) */
 392
 393         if (do_encrypt) {
 394                 return force_cli_encryption(*c,
 395                                         sharename);
 396         }
 397         return True;
 398 }
 399
 400 bool torture_open_connection(struct cli_state **c, int conn_index)
 401 {
 402         char **unc_list = NULL;
 403         int num_unc_names = 0;
 404         bool result;
 405
 406         if (use_multishare_conn==True) {
 407                 char *h, *s;
 408                 unc_list = file_lines_load(multishare_conn_fname, &num_unc_names, 0, NULL);
 409                 if (!unc_list || num_unc_names <= 0) {
 410                         printf("Failed to load unc names list from '%s'\n", multishare_conn_fname);
 411                         exit(1);
 412                 }
 413
 414                 if (!smbcli_parse_unc(unc_list[conn_index % num_unc_names],
 415                                       NULL, &h, &s)) {
 416                         printf("Failed to parse UNC name %s\n",
 417                                unc_list[conn_index % num_unc_names]);
 418                         TALLOC_FREE(unc_list);
 419                         exit(1);
 420                 }
 421
 422                 result = torture_open_connection_share(c, h, s);
 423
 424                 /* h, s were copied earlier */
 425                 TALLOC_FREE(unc_list);
 426                 return result;
 427         }
 428
 429         return torture_open_connection_share(c, host, share);
 430 }
 431
 432 bool torture_init_connection(struct cli_state **pcli)
 433 {
 434         struct cli_state *cli;
 435
 436         cli = open_nbt_connection();
 437         if (cli == NULL) {
 438                 return false;
 439         }
 440
 441         *pcli = cli;
 442         return true;
 443 }
 444
 445 bool torture_cli_session_setup2(struct cli_state *cli, uint16 *new_vuid)
 446 {
 447         uint16_t old_vuid = cli_state_get_uid(cli);
 448         fstring old_user_name;
 449         size_t passlen = strlen(password);
 450         NTSTATUS status;
 451         bool ret;
 452
 453         fstrcpy(old_user_name, cli->user_name);
 454         cli_state_set_uid(cli, 0);
 455         ret = NT_STATUS_IS_OK(cli_session_setup(cli, username,
 456                                                 password, passlen,
 457                                                 password, passlen,
 458                                                 workgroup));
 459         *new_vuid = cli_state_get_uid(cli);
 460         cli_state_set_uid(cli, old_vuid);
 461         status = cli_set_username(cli, old_user_name);
 462         if (!NT_STATUS_IS_OK(status)) {
 463                 return false;
 464         }
 465         return ret;
 466 }
 467
 468
 469 bool torture_close_connection(struct cli_state *c)
 470 {
 471         bool ret = True;
 472         NTSTATUS status;
 473
 474         status = cli_tdis(c);
 475         if (!NT_STATUS_IS_OK(status)) {
 476                 printf("tdis failed (%s)\n", nt_errstr(status));
 477                 ret = False;
 478         }
 479
 480         cli_shutdown(c);
 481
 482         return ret;
 483 }
 484
 485
 486 /* check if the server produced the expected dos or nt error code */
 487 static bool check_both_error(int line, NTSTATUS status,
 488                              uint8 eclass, uint32 ecode, NTSTATUS nterr)
 489 {
 490         if (NT_STATUS_IS_DOS(status)) {
 491                 uint8 cclass;
 492                 uint32 num;
 493
 494                 /* Check DOS error */
 495                 cclass = NT_STATUS_DOS_CLASS(status);
 496                 num = NT_STATUS_DOS_CODE(status);
 497
 498                 if (eclass != cclass || ecode != num) {
 499                         printf("unexpected error code class=%d code=%d\n",
 500                                (int)cclass, (int)num);
 501                         printf(" expected %d/%d %s (line=%d)\n",
 502                                (int)eclass, (int)ecode, nt_errstr(nterr), line);
 503                         return false;
 504                 }
 505         } else {
 506                 /* Check NT error */
 507                 if (!NT_STATUS_EQUAL(nterr, status)) {
 508                         printf("unexpected error code %s\n",
 509                                 nt_errstr(status));
 510                         printf(" expected %s (line=%d)\n",
 511                                 nt_errstr(nterr), line);
 512                         return false;
 513                 }
 514         }
 515
 516         return true;
 517 }
 518
 519
 520 /* check if the server produced the expected error code */
 521 static bool check_error(int line, NTSTATUS status,
 522                         uint8 eclass, uint32 ecode, NTSTATUS nterr)
 523 {
 524         if (NT_STATUS_IS_DOS(status)) {
 525                 uint8 cclass;
 526                 uint32 num;
 527
 528                 /* Check DOS error */
 529
 530                 cclass = NT_STATUS_DOS_CLASS(status);
 531                 num = NT_STATUS_DOS_CODE(status);
 532
 533                 if (eclass != cclass || ecode != num) {
 534                         printf("unexpected error code class=%d code=%d\n",
 535                                (int)cclass, (int)num);
 536                         printf(" expected %d/%d %s (line=%d)\n",
 537                                (int)eclass, (int)ecode, nt_errstr(nterr),
 538                                line);
 539                         return False;
 540                 }
 541
 542         } else {
 543                 /* Check NT error */
 544
 545                 if (NT_STATUS_V(nterr) != NT_STATUS_V(status)) {
 546                         printf("unexpected error code %s\n",
 547                                nt_errstr(status));
 548                         printf(" expected %s (line=%d)\n", nt_errstr(nterr),
 549                                line);
 550                         return False;
 551                 }
 552         }
 553
 554         return True;
 555 }
 556
 557
 558 static bool wait_lock(struct cli_state *c, int fnum, uint32 offset, uint32 len)
 559 {
 560         NTSTATUS status;
 561
 562         status = cli_lock32(c, fnum, offset, len, -1, WRITE_LOCK);
 563
 564         while (!NT_STATUS_IS_OK(status)) {
 565                 if (!check_both_error(__LINE__, status, ERRDOS,
 566                                       ERRlock, NT_STATUS_LOCK_NOT_GRANTED)) {
 567                         return false;
 568                 }
 569
 570                 status = cli_lock32(c, fnum, offset, len, -1, WRITE_LOCK);
 571         }
 572
 573         return true;
 574 }
 575
 576
 577 static bool rw_torture(struct cli_state *c)
 578 {
 579         const char *lockfname = "\\torture.lck";
 580         fstring fname;
 581         uint16_t fnum;
 582         uint16_t fnum2;
 583         pid_t pid2, pid = getpid();
 584         int i, j;
 585         char buf[1024];
 586         bool correct = True;
 587         size_t nread = 0;
 588         NTSTATUS status;
 589
 590         memset(buf, '\0', sizeof(buf));
 591
 592         status = cli_open(c, lockfname, O_RDWR | O_CREAT | O_EXCL,
 593                          DENY_NONE, &fnum2);
 594         if (!NT_STATUS_IS_OK(status)) {
 595                 status = cli_open(c, lockfname, O_RDWR, DENY_NONE, &fnum2);
 596         }
 597         if (!NT_STATUS_IS_OK(status)) {
 598                 printf("open of %s failed (%s)\n",
 599                        lockfname, nt_errstr(status));
 600                 return False;
 601         }
 602
 603         for (i=0;i<torture_numops;i++) {
 604                 unsigned n = (unsigned)sys_random()%10;
 605
 606                 if (i % 10 == 0) {
 607                         printf("%d\r", i); fflush(stdout);
 608                 }
 609                 slprintf(fname, sizeof(fstring) - 1, "\\torture.%u", n);
 610
 611                 if (!wait_lock(c, fnum2, n*sizeof(int), sizeof(int))) {
 612                         return False;
 613                 }
 614
 615                 status = cli_open(c, fname, O_RDWR | O_CREAT | O_TRUNC,
 616                                   DENY_ALL, &fnum);
 617                 if (!NT_STATUS_IS_OK(status)) {
 618                         printf("open failed (%s)\n", nt_errstr(status));
 619                         correct = False;
 620                         break;
 621                 }
 622
 623                 status = cli_writeall(c, fnum, 0, (uint8_t *)&pid, 0,
 624                                       sizeof(pid), NULL);
 625                 if (!NT_STATUS_IS_OK(status)) {
 626                         printf("write failed (%s)\n", nt_errstr(status));
 627                         correct = False;
 628                 }
 629
 630                 for (j=0;j<50;j++) {
 631                         status = cli_writeall(c, fnum, 0, (uint8_t *)buf,
 632                                               sizeof(pid)+(j*sizeof(buf)),
 633                                               sizeof(buf), NULL);
 634                         if (!NT_STATUS_IS_OK(status)) {
 635                                 printf("write failed (%s)\n",
 636                                        nt_errstr(status));
 637                                 correct = False;
 638                         }
 639                 }
 640
 641                 pid2 = 0;
 642
 643                 status = cli_read(c, fnum, (char *)&pid2, 0, sizeof(pid),
 644                                   &nread);
 645                 if (!NT_STATUS_IS_OK(status)) {
 646                         printf("read failed (%s)\n", nt_errstr(status));
 647                         correct = false;
 648                 } else if (nread != sizeof(pid)) {
 649                         printf("read/write compare failed: "
 650                                "recv %ld req %ld\n", (unsigned long)nread,
 651                                (unsigned long)sizeof(pid));
 652                         correct = false;
 653                 }
 654
 655                 if (pid2 != pid) {
 656                         printf("data corruption!\n");
 657                         correct = False;
 658                 }
 659
 660                 status = cli_close(c, fnum);
 661                 if (!NT_STATUS_IS_OK(status)) {
 662                         printf("close failed (%s)\n", nt_errstr(status));
 663                         correct = False;
 664                 }
 665
 666                 status = cli_unlink(c, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
 667                 if (!NT_STATUS_IS_OK(status)) {
 668                         printf("unlink failed (%s)\n", nt_errstr(status));
 669                         correct = False;
 670                 }
 671
 672                 status = cli_unlock(c, fnum2, n*sizeof(int), sizeof(int));
 673                 if (!NT_STATUS_IS_OK(status)) {
 674                         printf("unlock failed (%s)\n", nt_errstr(status));
 675                         correct = False;
 676                 }
 677         }
 678
 679         cli_close(c, fnum2);
 680         cli_unlink(c, lockfname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
 681
 682         printf("%d\n", i);
 683
 684         return correct;
 685 }
 686
 687 static bool run_torture(int dummy)
 688 {
 689         struct cli_state *cli;
 690         bool ret;
 691
 692         cli = current_cli;
 693
 694         cli_sockopt(cli, sockops);
 695
 696         ret = rw_torture(cli);
 697
 698         if (!torture_close_connection(cli)) {
 699                 ret = False;
 700         }
 701
 702         return ret;
 703 }
 704
 705 static bool rw_torture3(struct cli_state *c, char *lockfname)
 706 {
 707         uint16_t fnum = (uint16_t)-1;
 708         unsigned int i = 0;
 709         char buf[131072];
 710         char buf_rd[131072];
 711         unsigned count;
 712         unsigned countprev = 0;
 713         size_t sent = 0;
 714         bool correct = True;
 715         NTSTATUS status = NT_STATUS_OK;
 716
 717         srandom(1);
 718         for (i = 0; i < sizeof(buf); i += sizeof(uint32))
 719         {
 720                 SIVAL(buf, i, sys_random());
 721         }
 722
 723         if (procnum == 0)
 724         {
 725                 status = cli_unlink(
 726                         c, lockfname,
 727                         FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
 728                 if (!NT_STATUS_IS_OK(status)) {
 729                         printf("unlink failed (%s) (normal, this file should "
 730                                "not exist)\n", nt_errstr(status));
 731                 }
 732
 733                 status = cli_open(c, lockfname, O_RDWR | O_CREAT | O_EXCL,
 734                                   DENY_NONE, &fnum);
 735                 if (!NT_STATUS_IS_OK(status)) {
 736                         printf("first open read/write of %s failed (%s)\n",
 737                                         lockfname, nt_errstr(status));
 738                         return False;
 739                 }
 740         }
 741         else
 742         {
 743                 for (i = 0; i < 500 && fnum == (uint16_t)-1; i++)
 744                 {
 745                         status = cli_open(c, lockfname, O_RDONLY,
 746                                          DENY_NONE, &fnum);
 747                         if (!NT_STATUS_IS_OK(status)) {
 748                                 break;
 749                         }
 750                         smb_msleep(10);
 751                 }
 752                 if (!NT_STATUS_IS_OK(status)) {
 753                         printf("second open read-only of %s failed (%s)\n",
 754                                         lockfname, nt_errstr(status));
 755                         return False;
 756                 }
 757         }
 758
 759         i = 0;
 760         for (count = 0; count < sizeof(buf); count += sent)
 761         {
 762                 if (count >= countprev) {
 763                         printf("%d %8d\r", i, count);
 764                         fflush(stdout);
 765                         i++;
 766                         countprev += (sizeof(buf) / 20);
 767                 }
 768
 769                 if (procnum == 0)
 770                 {
 771                         sent = ((unsigned)sys_random()%(20))+ 1;
 772                         if (sent > sizeof(buf) - count)
 773                         {
 774                                 sent = sizeof(buf) - count;
 775                         }
 776
 777                         status = cli_writeall(c, fnum, 0, (uint8_t *)buf+count,
 778                                               count, sent, NULL);
 779                         if (!NT_STATUS_IS_OK(status)) {
 780                                 printf("write failed (%s)\n",
 781                                        nt_errstr(status));
 782                                 correct = False;
 783                         }
 784                 }
 785                 else
 786                 {
 787                         status = cli_read(c, fnum, buf_rd+count, count,
 788                                           sizeof(buf)-count, &sent);
 789                         if(!NT_STATUS_IS_OK(status)) {
 790                                 printf("read failed offset:%d size:%ld (%s)\n",
 791                                        count, (unsigned long)sizeof(buf)-count,
 792                                        nt_errstr(status));
 793                                 correct = False;
 794                                 sent = 0;
 795                         } else if (sent > 0) {
 796                                 if (memcmp(buf_rd+count, buf+count, sent) != 0)
 797                                 {
 798                                         printf("read/write compare failed\n");
 799                                         printf("offset: %d req %ld recvd %ld\n", count, (unsigned long)sizeof(buf)-count, (unsigned long)sent);
 800                                         correct = False;
 801                                         break;
 802                                 }
 803                         }
 804                 }
 805
 806         }
 807
 808         status = cli_close(c, fnum);
 809         if (!NT_STATUS_IS_OK(status)) {
 810                 printf("close failed (%s)\n", nt_errstr(status));
 811                 correct = False;
 812         }
 813
 814         return correct;
 815 }
 816
 817 static bool rw_torture2(struct cli_state *c1, struct cli_state *c2)
 818 {
 819         const char *lockfname = "\\torture2.lck";
 820         uint16_t fnum1;
 821         uint16_t fnum2;
 822         int i;
 823         char buf[131072];
 824         char buf_rd[131072];
 825         bool correct = True;
 826         size_t bytes_read;
 827         NTSTATUS status;
 828
 829         status = cli_unlink(c1, lockfname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
 830         if (!NT_STATUS_IS_OK(status)) {
 831                 printf("unlink failed (%s) (normal, this file should not exist)\n", nt_errstr(status));
 832         }
 833
 834         status = cli_open(c1, lockfname, O_RDWR | O_CREAT | O_EXCL,
 835                           DENY_NONE, &fnum1);
 836         if (!NT_STATUS_IS_OK(status)) {
 837                 printf("first open read/write of %s failed (%s)\n",
 838                                 lockfname, nt_errstr(status));
 839                 return False;
 840         }
 841
 842         status = cli_open(c2, lockfname, O_RDONLY, DENY_NONE, &fnum2);
 843         if (!NT_STATUS_IS_OK(status)) {
 844                 printf("second open read-only of %s failed (%s)\n",
 845                                 lockfname, nt_errstr(status));
 846                 cli_close(c1, fnum1);
 847                 return False;
 848         }
 849
 850         for (i = 0; i < torture_numops; i++)
 851         {
 852                 size_t buf_size = ((unsigned)sys_random()%(sizeof(buf)-1))+ 1;
 853                 if (i % 10 == 0) {
 854                         printf("%d\r", i); fflush(stdout);
 855                 }
 856
 857                 generate_random_buffer((unsigned char *)buf, buf_size);
 858
 859                 status = cli_writeall(c1, fnum1, 0, (uint8_t *)buf, 0,
 860                                       buf_size, NULL);
 861                 if (!NT_STATUS_IS_OK(status)) {
 862                         printf("write failed (%s)\n", nt_errstr(status));
 863                         correct = False;
 864                         break;
 865                 }
 866
 867                 status = cli_read(c2, fnum2, buf_rd, 0, buf_size, &bytes_read);
 868                 if(!NT_STATUS_IS_OK(status)) {
 869                         printf("read failed (%s)\n", nt_errstr(status));
 870                         correct = false;
 871                         break;
 872                 } else if (bytes_read != buf_size) {
 873                         printf("read failed\n");
 874                         printf("read %ld, expected %ld\n",
 875                                (unsigned long)bytes_read,
 876                                (unsigned long)buf_size);
 877                         correct = False;
 878                         break;
 879                 }
 880
 881                 if (memcmp(buf_rd, buf, buf_size) != 0)
 882                 {
 883                         printf("read/write compare failed\n");
 884                         correct = False;
 885                         break;
 886                 }
 887         }
 888
 889         status = cli_close(c2, fnum2);
 890         if (!NT_STATUS_IS_OK(status)) {
 891                 printf("close failed (%s)\n", nt_errstr(status));
 892                 correct = False;
 893         }
 894
 895         status = cli_close(c1, fnum1);
 896         if (!NT_STATUS_IS_OK(status)) {
 897                 printf("close failed (%s)\n", nt_errstr(status));
 898                 correct = False;
 899         }
 900
 901         status = cli_unlink(c1, lockfname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
 902         if (!NT_STATUS_IS_OK(status)) {
 903                 printf("unlink failed (%s)\n", nt_errstr(status));
 904                 correct = False;
 905         }
 906
 907         return correct;
 908 }
 909
 910 static bool run_readwritetest(int dummy)
 911 {
 912         struct cli_state *cli1, *cli2;
 913         bool test1, test2 = False;
 914
 915         if (!torture_open_connection(&cli1, 0) || !torture_open_connection(&cli2, 1)) {
 916                 return False;
 917         }
 918         cli_sockopt(cli1, sockops);
 919         cli_sockopt(cli2, sockops);
 920
 921         printf("starting readwritetest\n");
 922
 923         test1 = rw_torture2(cli1, cli2);
 924         printf("Passed readwritetest v1: %s\n", BOOLSTR(test1));
 925
 926         if (test1) {
 927                 test2 = rw_torture2(cli1, cli1);
 928                 printf("Passed readwritetest v2: %s\n", BOOLSTR(test2));
 929         }
 930
 931         if (!torture_close_connection(cli1)) {
 932                 test1 = False;
 933         }
 934
 935         if (!torture_close_connection(cli2)) {
 936                 test2 = False;
 937         }
 938
 939         return (test1 && test2);
 940 }
 941
 942 static bool run_readwritemulti(int dummy)
 943 {
 944         struct cli_state *cli;
 945         bool test;
 946
 947         cli = current_cli;
 948
 949         cli_sockopt(cli, sockops);
 950
 951         printf("run_readwritemulti: fname %s\n", randomfname);
 952         test = rw_torture3(cli, randomfname);
 953
 954         if (!torture_close_connection(cli)) {
 955                 test = False;
 956         }
 957
 958         return test;
 959 }
 960
 961 static bool run_readwritelarge_internal(int max_xmit_k)
 962 {
 963         static struct cli_state *cli1;
 964         uint16_t fnum1;
 965         const char *lockfname = "\\large.dat";
 966         SMB_OFF_T fsize;
 967         char buf[126*1024];
 968         bool correct = True;
 969         NTSTATUS status;
 970
 971         if (!torture_open_connection(&cli1, 0)) {
 972                 return False;
 973         }
 974         cli_sockopt(cli1, sockops);
 975         memset(buf,'\0',sizeof(buf));
 976
 977         cli1->max_xmit = max_xmit_k*1024;
 978
 979         if (signing_state == Required) {
 980                 /* Horrible cheat to force
 981                    multiple signed outstanding
 982                    packets against a Samba server.
 983                 */
 984                 cli1->is_samba = false;
 985         }
 986
 987         printf("starting readwritelarge_internal\n");
 988
 989         cli_unlink(cli1, lockfname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
 990
 991         status = cli_open(cli1, lockfname, O_RDWR | O_CREAT | O_EXCL,
 992                           DENY_NONE, &fnum1);
 993         if (!NT_STATUS_IS_OK(status)) {
 994                 printf("open read/write of %s failed (%s)\n", lockfname, nt_errstr(status));
 995                 return False;
 996         }
 997
 998         cli_writeall(cli1, fnum1, 0, (uint8_t *)buf, 0, sizeof(buf), NULL);
 999
1000         status = cli_qfileinfo_basic(cli1, fnum1, NULL, &fsize, NULL, NULL,
1001                                      NULL, NULL, NULL);
1002         if (!NT_STATUS_IS_OK(status)) {
1003                 printf("qfileinfo failed (%s)\n", nt_errstr(status));
1004                 correct = False;
1005         }
1006
1007         if (fsize == sizeof(buf))
1008                 printf("readwritelarge_internal test 1 succeeded (size = %lx)\n",
1009                        (unsigned long)fsize);
1010         else {
1011                 printf("readwritelarge_internal test 1 failed (size = %lx)\n",
1012                        (unsigned long)fsize);
1013                 correct = False;
1014         }
1015
1016         status = cli_close(cli1, fnum1);
1017         if (!NT_STATUS_IS_OK(status)) {
1018                 printf("close failed (%s)\n", nt_errstr(status));
1019                 correct = False;
1020         }
1021
1022         status = cli_unlink(cli1, lockfname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
1023         if (!NT_STATUS_IS_OK(status)) {
1024                 printf("unlink failed (%s)\n", nt_errstr(status));
1025                 correct = False;
1026         }
1027
1028         status = cli_open(cli1, lockfname, O_RDWR | O_CREAT | O_EXCL,
1029                           DENY_NONE, &fnum1);
1030         if (!NT_STATUS_IS_OK(status)) {
1031                 printf("open read/write of %s failed (%s)\n", lockfname, nt_errstr(status));
1032                 return False;
1033         }
1034
1035         cli1->max_xmit = 4*1024;
1036
1037         cli_smbwrite(cli1, fnum1, buf, 0, sizeof(buf), NULL);
1038
1039         status = cli_qfileinfo_basic(cli1, fnum1, NULL, &fsize, NULL, NULL,
1040                                      NULL, NULL, NULL);
1041         if (!NT_STATUS_IS_OK(status)) {
1042                 printf("qfileinfo failed (%s)\n", nt_errstr(status));
1043                 correct = False;
1044         }
1045
1046         if (fsize == sizeof(buf))
1047                 printf("readwritelarge_internal test 2 succeeded (size = %lx)\n",
1048                        (unsigned long)fsize);
1049         else {
1050                 printf("readwritelarge_internal test 2 failed (size = %lx)\n",
1051                        (unsigned long)fsize);
1052                 correct = False;
1053         }
1054
1055 #if 0
1056         /* ToDo - set allocation. JRA */
1057         if(!cli_set_allocation_size(cli1, fnum1, 0)) {
1058                 printf("set allocation size to zero failed (%s)\n", cli_errstr(&cli1));
1059                 return False;
1060         }
1061         if (!cli_qfileinfo_basic(cli1, fnum1, NULL, &fsize, NULL, NULL, NULL,
1062                                  NULL, NULL)) {
1063                 printf("qfileinfo failed (%s)\n", cli_errstr(cli1));
1064                 correct = False;
1065         }
1066         if (fsize != 0)
1067                 printf("readwritelarge test 3 (truncate test) succeeded (size = %x)\n", fsize);
1068 #endif
1069
1070         status = cli_close(cli1, fnum1);
1071         if (!NT_STATUS_IS_OK(status)) {
1072                 printf("close failed (%s)\n", nt_errstr(status));
1073                 correct = False;
1074         }
1075
1076         if (!torture_close_connection(cli1)) {
1077                 correct = False;
1078         }
1079         return correct;
1080 }
1081
1082 static bool run_readwritelarge(int dummy)
1083 {
1084         return run_readwritelarge_internal(128);
1085 }
1086
1087 static bool run_readwritelarge_signtest(int dummy)
1088 {
1089         bool ret;
1090         signing_state = Required;
1091         ret = run_readwritelarge_internal(2);
1092         signing_state = Undefined;
1093         return ret;
1094 }
1095
1096 int line_count = 0;
1097 int nbio_id;
1098
1099 #define ival(s) strtol(s, NULL, 0)
1100
1101 /* run a test that simulates an approximate netbench client load */
1102 static bool run_netbench(int client)
1103 {
1104         struct cli_state *cli;
1105         int i;
1106         char line[1024];
1107         char cname[20];
1108         FILE *f;
1109         const char *params[20];
1110         bool correct = True;
1111
1112         cli = current_cli;
1113
1114         nbio_id = client;
1115
1116         cli_sockopt(cli, sockops);
1117
1118         nb_setup(cli);
1119
1120         slprintf(cname,sizeof(cname)-1, "client%d", client);
1121
1122         f = fopen(client_txt, "r");
1123
1124         if (!f) {
1125                 perror(client_txt);
1126                 return False;
1127         }
1128
1129         while (fgets(line, sizeof(line)-1, f)) {
1130                 char *saveptr;
1131                 line_count++;
1132
1133                 line[strlen(line)-1] = 0;
1134
1135                 /* printf("[%d] %s\n", line_count, line); */
1136
1137                 all_string_sub(line,"client1", cname, sizeof(line));
1138
1139                 /* parse the command parameters */
1140                 params[0] = strtok_r(line, " ", &saveptr);
1141                 i = 0;
1142                 while (params[i]) params[++i] = strtok_r(NULL, " ", &saveptr);
1143
1144                 params[i] = "";
1145
1146                 if (i < 2) continue;
1147
1148                 if (!strncmp(params[0],"SMB", 3)) {
1149                         printf("ERROR: You are using a dbench 1 load file\n");
1150                         exit(1);
1151                 }
1152
1153                 if (!strcmp(params[0],"NTCreateX")) {
1154                         nb_createx(params[1], ival(params[2]), ival(params[3]),
1155                                    ival(params[4]));
1156                 } else if (!strcmp(params[0],"Close")) {
1157                         nb_close(ival(params[1]));
1158                 } else if (!strcmp(params[0],"Rename")) {
1159                         nb_rename(params[1], params[2]);
1160                 } else if (!strcmp(params[0],"Unlink")) {
1161                         nb_unlink(params[1]);
1162                 } else if (!strcmp(params[0],"Deltree")) {
1163                         nb_deltree(params[1]);
1164                 } else if (!strcmp(params[0],"Rmdir")) {
1165                         nb_rmdir(params[1]);
1166                 } else if (!strcmp(params[0],"QUERY_PATH_INFORMATION")) {
1167                         nb_qpathinfo(params[1]);
1168                 } else if (!strcmp(params[0],"QUERY_FILE_INFORMATION")) {
1169                         nb_qfileinfo(ival(params[1]));
1170                 } else if (!strcmp(params[0],"QUERY_FS_INFORMATION")) {
1171                         nb_qfsinfo(ival(params[1]));
1172                 } else if (!strcmp(params[0],"FIND_FIRST")) {
1173                         nb_findfirst(params[1]);
1174                 } else if (!strcmp(params[0],"WriteX")) {
1175                         nb_writex(ival(params[1]),
1176                                   ival(params[2]), ival(params[3]), ival(params[4]));
1177                 } else if (!strcmp(params[0],"ReadX")) {
1178                         nb_readx(ival(params[1]),
1179                                   ival(params[2]), ival(params[3]), ival(params[4]));
1180                 } else if (!strcmp(params[0],"Flush")) {
1181                         nb_flush(ival(params[1]));
1182                 } else {
1183                         printf("Unknown operation %s\n", params[0]);
1184                         exit(1);
1185                 }
1186         }
1187         fclose(f);
1188
1189         nb_cleanup();
1190
1191         if (!torture_close_connection(cli)) {
1192                 correct = False;
1193         }
1194
1195         return correct;
1196 }
1197
1198
1199 /* run a test that simulates an approximate netbench client load */
1200 static bool run_nbench(int dummy)
1201 {
1202         double t;
1203         bool correct = True;
1204
1205         nbio_shmem(nprocs);
1206
1207         nbio_id = -1;
1208
1209         signal(SIGALRM, nb_alarm);
1210         alarm(1);
1211         t = create_procs(run_netbench, &correct);
1212         alarm(0);
1213
1214         printf("\nThroughput %g MB/sec\n",
1215                1.0e-6 * nbio_total() / t);
1216         return correct;
1217 }
1218
1219
1220 /*
1221   This test checks for two things:
1222
1223   1) correct support for retaining locks over a close (ie. the server
1224      must not use posix semantics)
1225   2) support for lock timeouts
1226  */
1227 static bool run_locktest1(int dummy)
1228 {
1229         struct cli_state *cli1, *cli2;
1230         const char *fname = "\\lockt1.lck";
1231         uint16_t fnum1, fnum2, fnum3;
1232         time_t t1, t2;
1233         unsigned lock_timeout;
1234         NTSTATUS status;
1235
1236         if (!torture_open_connection(&cli1, 0) || !torture_open_connection(&cli2, 1)) {
1237                 return False;
1238         }
1239         cli_sockopt(cli1, sockops);
1240         cli_sockopt(cli2, sockops);
1241
1242         printf("starting locktest1\n");
1243
1244         cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
1245
1246         status = cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE,
1247                           &fnum1);
1248         if (!NT_STATUS_IS_OK(status)) {
1249                 printf("open of %s failed (%s)\n", fname, nt_errstr(status));
1250                 return False;
1251         }
1252
1253         status = cli_open(cli1, fname, O_RDWR, DENY_NONE, &fnum2);
1254         if (!NT_STATUS_IS_OK(status)) {
1255                 printf("open2 of %s failed (%s)\n", fname, nt_errstr(status));
1256                 return False;
1257         }
1258
1259         status = cli_open(cli2, fname, O_RDWR, DENY_NONE, &fnum3);
1260         if (!NT_STATUS_IS_OK(status)) {
1261                 printf("open3 of %s failed (%s)\n", fname, nt_errstr(status));
1262                 return False;
1263         }
1264
1265         status = cli_lock32(cli1, fnum1, 0, 4, 0, WRITE_LOCK);
1266         if (!NT_STATUS_IS_OK(status)) {
1267                 printf("lock1 failed (%s)\n", nt_errstr(status));
1268                 return false;
1269         }
1270
1271         status = cli_lock32(cli2, fnum3, 0, 4, 0, WRITE_LOCK);
1272         if (NT_STATUS_IS_OK(status)) {
1273                 printf("lock2 succeeded! This is a locking bug\n");
1274                 return false;
1275         } else {
1276                 if (!check_both_error(__LINE__, status, ERRDOS, ERRlock,
1277                                       NT_STATUS_LOCK_NOT_GRANTED)) {
1278                         return false;
1279                 }
1280         }
1281
1282         lock_timeout = (1 + (random() % 20));
1283         printf("Testing lock timeout with timeout=%u\n", lock_timeout);
1284         t1 = time(NULL);
1285         status = cli_lock32(cli2, fnum3, 0, 4, lock_timeout * 1000, WRITE_LOCK);
1286         if (NT_STATUS_IS_OK(status)) {
1287                 printf("lock3 succeeded! This is a locking bug\n");
1288                 return false;
1289         } else {
1290                 if (!check_both_error(__LINE__, status, ERRDOS, ERRlock,
1291                                       NT_STATUS_FILE_LOCK_CONFLICT)) {
1292                         return false;
1293                 }
1294         }
1295         t2 = time(NULL);
1296
1297         if (ABS(t2 - t1) < lock_timeout-1) {
1298                 printf("error: This server appears not to support timed lock requests\n");
1299         }
1300
1301         printf("server slept for %u seconds for a %u second timeout\n",
1302                (unsigned int)(t2-t1), lock_timeout);
1303
1304         status = cli_close(cli1, fnum2);
1305         if (!NT_STATUS_IS_OK(status)) {
1306                 printf("close1 failed (%s)\n", nt_errstr(status));
1307                 return False;
1308         }
1309
1310         status = cli_lock32(cli2, fnum3, 0, 4, 0, WRITE_LOCK);
1311         if (NT_STATUS_IS_OK(status)) {
1312                 printf("lock4 succeeded! This is a locking bug\n");
1313                 return false;
1314         } else {
1315                 if (!check_both_error(__LINE__, status, ERRDOS, ERRlock,
1316                                       NT_STATUS_FILE_LOCK_CONFLICT)) {
1317                         return false;
1318                 }
1319         }
1320
1321         status = cli_close(cli1, fnum1);
1322         if (!NT_STATUS_IS_OK(status)) {
1323                 printf("close2 failed (%s)\n", nt_errstr(status));
1324                 return False;
1325         }
1326
1327         status = cli_close(cli2, fnum3);
1328         if (!NT_STATUS_IS_OK(status)) {
1329                 printf("close3 failed (%s)\n", nt_errstr(status));
1330                 return False;
1331         }
1332
1333         status = cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
1334         if (!NT_STATUS_IS_OK(status)) {
1335                 printf("unlink failed (%s)\n", nt_errstr(status));
1336                 return False;
1337         }
1338
1339
1340         if (!torture_close_connection(cli1)) {
1341                 return False;
1342         }
1343
1344         if (!torture_close_connection(cli2)) {
1345                 return False;
1346         }
1347
1348         printf("Passed locktest1\n");
1349         return True;
1350 }
1351
1352 /*
1353   this checks to see if a secondary tconx can use open files from an
1354   earlier tconx
1355  */
1356 static bool run_tcon_test(int dummy)
1357 {
1358         static struct cli_state *cli;
1359         const char *fname = "\\tcontest.tmp";
1360         uint16 fnum1;
1361         uint16 cnum1, cnum2, cnum3;
1362         uint16 vuid1, vuid2;
1363         char buf[4];
1364         bool ret = True;
1365         NTSTATUS status;
1366
1367         memset(buf, '\0', sizeof(buf));
1368
1369         if (!torture_open_connection(&cli, 0)) {
1370                 return False;
1371         }
1372         cli_sockopt(cli, sockops);
1373
1374         printf("starting tcontest\n");
1375
1376         cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
1377
1378         status = cli_open(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1);
1379         if (!NT_STATUS_IS_OK(status)) {
1380                 printf("open of %s failed (%s)\n", fname, nt_errstr(status));
1381                 return False;
1382         }
1383
1384         cnum1 = cli_state_get_tid(cli);
1385         vuid1 = cli_state_get_uid(cli);
1386
1387         status = cli_writeall(cli, fnum1, 0, (uint8_t *)buf, 130, 4, NULL);
1388         if (!NT_STATUS_IS_OK(status)) {
1389                 printf("initial write failed (%s)", nt_errstr(status));
1390                 return False;
1391         }
1392
1393         status = cli_tcon_andx(cli, share, "?????",
1394                                password, strlen(password)+1);
1395         if (!NT_STATUS_IS_OK(status)) {
1396                 printf("%s refused 2nd tree connect (%s)\n", host,
1397                        nt_errstr(status));
1398                 cli_shutdown(cli);
1399                 return False;
1400         }
1401
1402         cnum2 = cli_state_get_tid(cli);
1403         cnum3 = MAX(cnum1, cnum2) + 1; /* any invalid number */
1404         vuid2 = cli_state_get_uid(cli) + 1;
1405
1406         /* try a write with the wrong tid */
1407         cli_state_set_tid(cli, cnum2);
1408
1409         status = cli_writeall(cli, fnum1, 0, (uint8_t *)buf, 130, 4, NULL);
1410         if (NT_STATUS_IS_OK(status)) {
1411                 printf("* server allows write with wrong TID\n");
1412                 ret = False;
1413         } else {
1414                 printf("server fails write with wrong TID : %s\n",
1415                        nt_errstr(status));
1416         }
1417
1418
1419         /* try a write with an invalid tid */
1420         cli_state_set_tid(cli, cnum3);
1421
1422         status = cli_writeall(cli, fnum1, 0, (uint8_t *)buf, 130, 4, NULL);
1423         if (NT_STATUS_IS_OK(status)) {
1424                 printf("* server allows write with invalid TID\n");
1425                 ret = False;
1426         } else {
1427                 printf("server fails write with invalid TID : %s\n",
1428                        nt_errstr(status));
1429         }
1430
1431         /* try a write with an invalid vuid */
1432         cli_state_set_uid(cli, vuid2);
1433         cli_state_set_tid(cli, cnum1);
1434
1435         status = cli_writeall(cli, fnum1, 0, (uint8_t *)buf, 130, 4, NULL);
1436         if (NT_STATUS_IS_OK(status)) {
1437                 printf("* server allows write with invalid VUID\n");
1438                 ret = False;
1439         } else {
1440                 printf("server fails write with invalid VUID : %s\n",
1441                        nt_errstr(status));
1442         }
1443
1444         cli_state_set_tid(cli, cnum1);
1445         cli_state_set_uid(cli, vuid1);
1446
1447         status = cli_close(cli, fnum1);
1448         if (!NT_STATUS_IS_OK(status)) {
1449                 printf("close failed (%s)\n", nt_errstr(status));
1450                 return False;
1451         }
1452
1453         cli_state_set_tid(cli, cnum2);
1454
1455         status = cli_tdis(cli);
1456         if (!NT_STATUS_IS_OK(status)) {
1457                 printf("secondary tdis failed (%s)\n", nt_errstr(status));
1458                 return False;
1459         }
1460
1461         cli_state_set_tid(cli, cnum1);
1462
1463         if (!torture_close_connection(cli)) {
1464                 return False;
1465         }
1466
1467         return ret;
1468 }
1469
1470
1471 /*
1472  checks for old style tcon support
1473  */
1474 static bool run_tcon2_test(int dummy)
1475 {
1476         static struct cli_state *cli;
1477         uint16 cnum, max_xmit;
1478         char *service;
1479         NTSTATUS status;
1480
1481         if (!torture_open_connection(&cli, 0)) {
1482                 return False;
1483         }
1484         cli_sockopt(cli, sockops);
1485
1486         printf("starting tcon2 test\n");
1487
1488         if (asprintf(&service, "\\\\%s\\%s", host, share) == -1) {
1489                 return false;
1490         }
1491
1492         status = cli_raw_tcon(cli, service, password, "?????", &max_xmit, &cnum);
1493
1494         SAFE_FREE(service);
1495
1496         if (!NT_STATUS_IS_OK(status)) {
1497                 printf("tcon2 failed : %s\n", nt_errstr(status));
1498         } else {
1499                 printf("tcon OK : max_xmit=%d cnum=%d\n",
1500                        (int)max_xmit, (int)cnum);
1501         }
1502
1503         if (!torture_close_connection(cli)) {
1504                 return False;
1505         }
1506
1507         printf("Passed tcon2 test\n");
1508         return True;
1509 }
1510
1511 static bool tcon_devtest(struct cli_state *cli,
1512                          const char *myshare, const char *devtype,
1513                          const char *return_devtype,
1514                          NTSTATUS expected_error)
1515 {
1516         NTSTATUS status;
1517         bool ret;
1518
1519         status = cli_tcon_andx(cli, myshare, devtype,
1520                                password, strlen(password)+1);
1521
1522         if (NT_STATUS_IS_OK(expected_error)) {
1523                 if (NT_STATUS_IS_OK(status)) {
1524                         if (strcmp(cli->dev, return_devtype) == 0) {
1525                                 ret = True;
1526                         } else {
1527                                 printf("tconX to share %s with type %s "
1528                                        "succeeded but returned the wrong "
1529                                        "device type (got [%s] but should have got [%s])\n",
1530                                        myshare, devtype, cli->dev, return_devtype);
1531                                 ret = False;
1532                         }
1533                 } else {
1534                         printf("tconX to share %s with type %s "
1535                                "should have succeeded but failed\n",
1536                                myshare, devtype);
1537                         ret = False;
1538                 }
1539                 cli_tdis(cli);
1540         } else {
1541                 if (NT_STATUS_IS_OK(status)) {
1542                         printf("tconx to share %s with type %s "
1543                                "should have failed but succeeded\n",
1544                                myshare, devtype);
1545                         ret = False;
1546                 } else {
1547                         if (NT_STATUS_EQUAL(cli_nt_error(cli),
1548                                             expected_error)) {
1549                                 ret = True;
1550                         } else {
1551                                 printf("Returned unexpected error\n");
1552                                 ret = False;
1553                         }
1554                 }
1555         }
1556         return ret;
1557 }
1558
1559 /*
1560  checks for correct tconX support
1561  */
1562 static bool run_tcon_devtype_test(int dummy)
1563 {
1564         static struct cli_state *cli1 = NULL;
1565         int flags = 0;
1566         NTSTATUS status;
1567         bool ret = True;
1568
1569         status = cli_full_connection(&cli1, myname,
1570                                      host, NULL, port_to_use,
1571                                      NULL, NULL,
1572                                      username, workgroup,
1573                                      password, flags, signing_state);
1574
1575         if (!NT_STATUS_IS_OK(status)) {
1576                 printf("could not open connection\n");
1577                 return False;
1578         }
1579
1580         if (!tcon_devtest(cli1, "IPC$", "A:", NULL, NT_STATUS_BAD_DEVICE_TYPE))
1581                 ret = False;
1582
1583         if (!tcon_devtest(cli1, "IPC$", "?????", "IPC", NT_STATUS_OK))
1584                 ret = False;
1585
1586         if (!tcon_devtest(cli1, "IPC$", "LPT:", NULL, NT_STATUS_BAD_DEVICE_TYPE))
1587                 ret = False;
1588
1589         if (!tcon_devtest(cli1, "IPC$", "IPC", "IPC", NT_STATUS_OK))
1590                 ret = False;
1591
1592         if (!tcon_devtest(cli1, "IPC$", "FOOBA", NULL, NT_STATUS_BAD_DEVICE_TYPE))
1593                 ret = False;
1594
1595         if (!tcon_devtest(cli1, share, "A:", "A:", NT_STATUS_OK))
1596                 ret = False;
1597
1598         if (!tcon_devtest(cli1, share, "?????", "A:", NT_STATUS_OK))
1599                 ret = False;
1600
1601         if (!tcon_devtest(cli1, share, "LPT:", NULL, NT_STATUS_BAD_DEVICE_TYPE))
1602                 ret = False;
1603
1604         if (!tcon_devtest(cli1, share, "IPC", NULL, NT_STATUS_BAD_DEVICE_TYPE))
1605                 ret = False;
1606
1607         if (!tcon_devtest(cli1, share, "FOOBA", NULL, NT_STATUS_BAD_DEVICE_TYPE))
1608                 ret = False;
1609
1610         cli_shutdown(cli1);
1611
1612         if (ret)
1613                 printf("Passed tcondevtest\n");
1614
1615         return ret;
1616 }
1617
1618
1619 /*
1620   This test checks that
1621
1622   1) the server supports multiple locking contexts on the one SMB
1623   connection, distinguished by PID.
1624
1625   2) the server correctly fails overlapping locks made by the same PID (this
1626      goes against POSIX behaviour, which is why it is tricky to implement)
1627
1628   3) the server denies unlock requests by an incorrect client PID
1629 */
1630 static bool run_locktest2(int dummy)
1631 {
1632         static struct cli_state *cli;
1633         const char *fname = "\\lockt2.lck";
1634         uint16_t fnum1, fnum2, fnum3;
1635         bool correct = True;
1636         NTSTATUS status;
1637
1638         if (!torture_open_connection(&cli, 0)) {
1639                 return False;
1640         }
1641
1642         cli_sockopt(cli, sockops);
1643
1644         printf("starting locktest2\n");
1645
1646         cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
1647
1648         cli_setpid(cli, 1);
1649
1650         status = cli_open(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1);
1651         if (!NT_STATUS_IS_OK(status)) {
1652                 printf("open of %s failed (%s)\n", fname, nt_errstr(status));
1653                 return False;
1654         }
1655
1656         status = cli_open(cli, fname, O_RDWR, DENY_NONE, &fnum2);
1657         if (!NT_STATUS_IS_OK(status)) {
1658                 printf("open2 of %s failed (%s)\n", fname, nt_errstr(status));
1659                 return False;
1660         }
1661
1662         cli_setpid(cli, 2);
1663
1664         status = cli_open(cli, fname, O_RDWR, DENY_NONE, &fnum3);
1665         if (!NT_STATUS_IS_OK(status)) {
1666                 printf("open3 of %s failed (%s)\n", fname, nt_errstr(status));
1667                 return False;
1668         }
1669
1670         cli_setpid(cli, 1);
1671
1672         status = cli_lock32(cli, fnum1, 0, 4, 0, WRITE_LOCK);
1673         if (!NT_STATUS_IS_OK(status)) {
1674                 printf("lock1 failed (%s)\n", nt_errstr(status));
1675                 return false;
1676         }
1677
1678         status = cli_lock32(cli, fnum1, 0, 4, 0, WRITE_LOCK);
1679         if (NT_STATUS_IS_OK(status)) {
1680                 printf("WRITE lock1 succeeded! This is a locking bug\n");
1681                 correct = false;
1682         } else {
1683                 if (!check_both_error(__LINE__, status, ERRDOS, ERRlock,
1684                                       NT_STATUS_LOCK_NOT_GRANTED)) {
1685                         return false;
1686                 }
1687         }
1688
1689         status = cli_lock32(cli, fnum2, 0, 4, 0, WRITE_LOCK);
1690         if (NT_STATUS_IS_OK(status)) {
1691                 printf("WRITE lock2 succeeded! This is a locking bug\n");
1692                 correct = false;
1693         } else {
1694                 if (!check_both_error(__LINE__, status, ERRDOS, ERRlock,
1695                                       NT_STATUS_LOCK_NOT_GRANTED)) {
1696                         return false;
1697                 }
1698         }
1699
1700         status = cli_lock32(cli, fnum2, 0, 4, 0, READ_LOCK);
1701         if (NT_STATUS_IS_OK(status)) {
1702                 printf("READ lock2 succeeded! This is a locking bug\n");
1703                 correct = false;
1704         } else {
1705                 if (!check_both_error(__LINE__, status, ERRDOS, ERRlock,
1706                                  NT_STATUS_FILE_LOCK_CONFLICT)) {
1707                         return false;
1708                 }
1709         }
1710
1711         status = cli_lock32(cli, fnum1, 100, 4, 0, WRITE_LOCK);
1712         if (!NT_STATUS_IS_OK(status)) {
1713                 printf("lock at 100 failed (%s)\n", nt_errstr(status));
1714         }
1715         cli_setpid(cli, 2);
1716         if (NT_STATUS_IS_OK(cli_unlock(cli, fnum1, 100, 4))) {
1717                 printf("unlock at 100 succeeded! This is a locking bug\n");
1718                 correct = False;
1719         }
1720
1721         status = cli_unlock(cli, fnum1, 0, 4);
1722         if (NT_STATUS_IS_OK(status)) {
1723                 printf("unlock1 succeeded! This is a locking bug\n");
1724                 correct = false;
1725         } else {
1726                 if (!check_both_error(__LINE__, status, ERRDOS, ERRlock,
1727                                       NT_STATUS_RANGE_NOT_LOCKED)) {
1728                         return false;
1729                 }
1730         }
1731
1732         status = cli_unlock(cli, fnum1, 0, 8);
1733         if (NT_STATUS_IS_OK(status)) {
1734                 printf("unlock2 succeeded! This is a locking bug\n");
1735                 correct = false;
1736         } else {
1737                 if (!check_both_error(__LINE__, status, ERRDOS, ERRlock,
1738                                       NT_STATUS_RANGE_NOT_LOCKED)) {
1739                         return false;
1740                 }
1741         }
1742
1743         status = cli_lock32(cli, fnum3, 0, 4, 0, WRITE_LOCK);
1744         if (NT_STATUS_IS_OK(status)) {
1745                 printf("lock3 succeeded! This is a locking bug\n");
1746                 correct = false;
1747         } else {
1748                 if (!check_both_error(__LINE__, status, ERRDOS, ERRlock,
1749                                       NT_STATUS_LOCK_NOT_GRANTED)) {
1750                         return false;
1751                 }
1752         }
1753
1754         cli_setpid(cli, 1);
1755
1756         status = cli_close(cli, fnum1);
1757         if (!NT_STATUS_IS_OK(status)) {
1758                 printf("close1 failed (%s)\n", nt_errstr(status));
1759                 return False;
1760         }
1761
1762         status = cli_close(cli, fnum2);
1763         if (!NT_STATUS_IS_OK(status)) {
1764                 printf("close2 failed (%s)\n", nt_errstr(status));
1765                 return False;
1766         }
1767
1768         status = cli_close(cli, fnum3);
1769         if (!NT_STATUS_IS_OK(status)) {
1770                 printf("close3 failed (%s)\n", nt_errstr(status));
1771                 return False;
1772         }
1773
1774         if (!torture_close_connection(cli)) {
1775                 correct = False;
1776         }
1777
1778         printf("locktest2 finished\n");
1779
1780         return correct;
1781 }
1782
1783
1784 /*
1785   This test checks that
1786
1787   1) the server supports the full offset range in lock requests
1788 */
1789 static bool run_locktest3(int dummy)
1790 {
1791         static struct cli_state *cli1, *cli2;
1792         const char *fname = "\\lockt3.lck";
1793         uint16_t fnum1, fnum2;
1794         int i;
1795         uint32 offset;
1796         bool correct = True;
1797         NTSTATUS status;
1798
1799 #define NEXT_OFFSET offset += (~(uint32)0) / torture_numops
1800
1801         if (!torture_open_connection(&cli1, 0) || !torture_open_connection(&cli2, 1)) {
1802                 return False;
1803         }
1804         cli_sockopt(cli1, sockops);
1805         cli_sockopt(cli2, sockops);
1806
1807         printf("starting locktest3\n");
1808
1809         cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
1810
1811         status = cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE,
1812                          &fnum1);
1813         if (!NT_STATUS_IS_OK(status)) {
1814                 printf("open of %s failed (%s)\n", fname, nt_errstr(status));
1815                 return False;
1816         }
1817
1818         status = cli_open(cli2, fname, O_RDWR, DENY_NONE, &fnum2);
1819         if (!NT_STATUS_IS_OK(status)) {
1820                 printf("open2 of %s failed (%s)\n", fname, nt_errstr(status));
1821                 return False;
1822         }
1823
1824         for (offset=i=0;i<torture_numops;i++) {
1825                 NEXT_OFFSET;
1826
1827                 status = cli_lock32(cli1, fnum1, offset-1, 1, 0, WRITE_LOCK);
1828                 if (!NT_STATUS_IS_OK(status)) {
1829                         printf("lock1 %d failed (%s)\n",
1830                                i,
1831                                nt_errstr(status));
1832                         return False;
1833                 }
1834
1835                 status = cli_lock32(cli2, fnum2, offset-2, 1, 0, WRITE_LOCK);
1836                 if (!NT_STATUS_IS_OK(status)) {
1837                         printf("lock2 %d failed (%s)\n",
1838                                i,
1839                                nt_errstr(status));
1840                         return False;
1841                 }
1842         }
1843
1844         for (offset=i=0;i<torture_numops;i++) {
1845                 NEXT_OFFSET;
1846
1847                 status = cli_lock32(cli1, fnum1, offset-2, 1, 0, WRITE_LOCK);
1848                 if (NT_STATUS_IS_OK(status)) {
1849                         printf("error: lock1 %d succeeded!\n", i);
1850                         return False;
1851                 }
1852
1853                 status = cli_lock32(cli2, fnum2, offset-1, 1, 0, WRITE_LOCK);
1854                 if (NT_STATUS_IS_OK(status)) {
1855                         printf("error: lock2 %d succeeded!\n", i);
1856                         return False;
1857                 }
1858
1859                 status = cli_lock32(cli1, fnum1, offset-1, 1, 0, WRITE_LOCK);
1860                 if (NT_STATUS_IS_OK(status)) {
1861                         printf("error: lock3 %d succeeded!\n", i);
1862                         return False;
1863                 }
1864
1865                 status = cli_lock32(cli2, fnum2, offset-2, 1, 0, WRITE_LOCK);
1866                 if (NT_STATUS_IS_OK(status)) {
1867                         printf("error: lock4 %d succeeded!\n", i);
1868                         return False;
1869                 }
1870         }
1871
1872         for (offset=i=0;i<torture_numops;i++) {
1873                 NEXT_OFFSET;
1874
1875                 status = cli_unlock(cli1, fnum1, offset-1, 1);
1876                 if (!NT_STATUS_IS_OK(status)) {
1877                         printf("unlock1 %d failed (%s)\n",
1878                                i,
1879                                nt_errstr(status));
1880                         return False;
1881                 }
1882
1883                 status = cli_unlock(cli2, fnum2, offset-2, 1);
1884                 if (!NT_STATUS_IS_OK(status)) {
1885                         printf("unlock2 %d failed (%s)\n",
1886                                i,
1887                                nt_errstr(status));
1888                         return False;
1889                 }
1890         }
1891
1892         status = cli_close(cli1, fnum1);
1893         if (!NT_STATUS_IS_OK(status)) {
1894                 printf("close1 failed (%s)\n", nt_errstr(status));
1895                 return False;
1896         }
1897
1898         status = cli_close(cli2, fnum2);
1899         if (!NT_STATUS_IS_OK(status)) {
1900                 printf("close2 failed (%s)\n", nt_errstr(status));
1901                 return False;
1902         }
1903
1904         status = cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
1905         if (!NT_STATUS_IS_OK(status)) {
1906                 printf("unlink failed (%s)\n", nt_errstr(status));
1907                 return False;
1908         }
1909
1910         if (!torture_close_connection(cli1)) {
1911                 correct = False;
1912         }
1913
1914         if (!torture_close_connection(cli2)) {
1915                 correct = False;
1916         }
1917
1918         printf("finished locktest3\n");
1919
1920         return correct;
1921 }
1922
1923 static bool test_cli_read(struct cli_state *cli, uint16_t fnum,
1924                            char *buf, off_t offset, size_t size,
1925                            size_t *nread, size_t expect)
1926 {
1927         NTSTATUS status;
1928         size_t l_nread;
1929
1930         status = cli_read(cli, fnum, buf, offset, size, &l_nread);
1931
1932         if(!NT_STATUS_IS_OK(status)) {
1933                 return false;
1934         } else if (l_nread != expect) {
1935                 return false;
1936         }
1937
1938         if (nread) {
1939                 *nread = l_nread;
1940         }
1941
1942         return true;
1943 }
1944
1945 #define EXPECTED(ret, v) if ((ret) != (v)) { \
1946         printf("** "); correct = False; \
1947         }
1948
1949 /*
1950   looks at overlapping locks
1951 */
1952 static bool run_locktest4(int dummy)
1953 {
1954         static struct cli_state *cli1, *cli2;
1955         const char *fname = "\\lockt4.lck";
1956         uint16_t fnum1, fnum2, f;
1957         bool ret;
1958         char buf[1000];
1959         bool correct = True;
1960         NTSTATUS status;
1961
1962         if (!torture_open_connection(&cli1, 0) || !torture_open_connection(&cli2, 1)) {
1963                 return False;
1964         }
1965
1966         cli_sockopt(cli1, sockops);
1967         cli_sockopt(cli2, sockops);
1968
1969         printf("starting locktest4\n");
1970
1971         cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
1972
1973         cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1);
1974         cli_open(cli2, fname, O_RDWR, DENY_NONE, &fnum2);
1975
1976         memset(buf, 0, sizeof(buf));
1977
1978         status = cli_writeall(cli1, fnum1, 0, (uint8_t *)buf, 0, sizeof(buf),
1979                               NULL);
1980         if (!NT_STATUS_IS_OK(status)) {
1981                 printf("Failed to create file: %s\n", nt_errstr(status));
1982                 correct = False;
1983                 goto fail;
1984         }
1985
1986         ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 0, 4, 0, WRITE_LOCK)) &&
1987               NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 2, 4, 0, WRITE_LOCK));
1988         EXPECTED(ret, False);
1989         printf("the same process %s set overlapping write locks\n", ret?"can":"cannot");
1990
1991         ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 10, 4, 0, READ_LOCK)) &&
1992               NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 12, 4, 0, READ_LOCK));
1993         EXPECTED(ret, True);
1994         printf("the same process %s set overlapping read locks\n", ret?"can":"cannot");
1995
1996         ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 20, 4, 0, WRITE_LOCK)) &&
1997               NT_STATUS_IS_OK(cli_lock32(cli2, fnum2, 22, 4, 0, WRITE_LOCK));
1998         EXPECTED(ret, False);
1999         printf("a different connection %s set overlapping write locks\n", ret?"can":"cannot");
2000
2001         ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 30, 4, 0, READ_LOCK)) &&
2002               NT_STATUS_IS_OK(cli_lock32(cli2, fnum2, 32, 4, 0, READ_LOCK));
2003         EXPECTED(ret, True);
2004         printf("a different connection %s set overlapping read locks\n", ret?"can":"cannot");
2005
2006         ret = (cli_setpid(cli1, 1),
2007               NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 40, 4, 0, WRITE_LOCK))) &&
2008               (cli_setpid(cli1, 2),
2009               NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 42, 4, 0, WRITE_LOCK)));
2010         EXPECTED(ret, False);
2011         printf("a different pid %s set overlapping write locks\n", ret?"can":"cannot");
2012
2013         ret = (cli_setpid(cli1, 1),
2014               NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 50, 4, 0, READ_LOCK))) &&
2015               (cli_setpid(cli1, 2),
2016               NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 52, 4, 0, READ_LOCK)));
2017         EXPECTED(ret, True);
2018         printf("a different pid %s set overlapping read locks\n", ret?"can":"cannot");
2019
2020         ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 60, 4, 0, READ_LOCK)) &&
2021               NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 60, 4, 0, READ_LOCK));
2022         EXPECTED(ret, True);
2023         printf("the same process %s set the same read lock twice\n", ret?"can":"cannot");
2024
2025         ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 70, 4, 0, WRITE_LOCK)) &&
2026               NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 70, 4, 0, WRITE_LOCK));
2027         EXPECTED(ret, False);
2028         printf("the same process %s set the same write lock twice\n", ret?"can":"cannot");
2029
2030         ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 80, 4, 0, READ_LOCK)) &&
2031               NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 80, 4, 0, WRITE_LOCK));
2032         EXPECTED(ret, False);
2033         printf("the same process %s overlay a read lock with a write lock\n", ret?"can":"cannot");
2034
2035         ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 90, 4, 0, WRITE_LOCK)) &&
2036               NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 90, 4, 0, READ_LOCK));
2037         EXPECTED(ret, True);
2038         printf("the same process %s overlay a write lock with a read lock\n", ret?"can":"cannot");
2039
2040         ret = (cli_setpid(cli1, 1),
2041              NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 100, 4, 0, WRITE_LOCK))) &&
2042              (cli_setpid(cli1, 2),
2043              NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 100, 4, 0, READ_LOCK)));
2044         EXPECTED(ret, False);
2045         printf("a different pid %s overlay a write lock with a read lock\n", ret?"can":"cannot");
2046
2047         ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 110, 4, 0, READ_LOCK)) &&
2048               NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 112, 4, 0, READ_LOCK)) &&
2049               NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 110, 6));
2050         EXPECTED(ret, False);
2051         printf("the same process %s coalesce read locks\n", ret?"can":"cannot");
2052
2053
2054         ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 120, 4, 0, WRITE_LOCK)) &&
2055               test_cli_read(cli2, fnum2, buf, 120, 4, NULL, 4);
2056         EXPECTED(ret, False);
2057         printf("this server %s strict write locking\n", ret?"doesn't do":"does");
2058
2059         status = cli_lock32(cli1, fnum1, 130, 4, 0, READ_LOCK);
2060         ret = NT_STATUS_IS_OK(status);
2061         if (ret) {
2062                 status = cli_writeall(cli2, fnum2, 0, (uint8_t *)buf, 130, 4,
2063                                       NULL);
2064                 ret = NT_STATUS_IS_OK(status);
2065         }
2066         EXPECTED(ret, False);
2067         printf("this server %s strict read locking\n", ret?"doesn't do":"does");
2068
2069
2070         ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 140, 4, 0, READ_LOCK)) &&
2071               NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 140, 4, 0, READ_LOCK)) &&
2072               NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 140, 4)) &&
2073               NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 140, 4));
2074         EXPECTED(ret, True);
2075         printf("this server %s do recursive read locking\n", ret?"does":"doesn't");
2076
2077
2078         ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 150, 4, 0, WRITE_LOCK)) &&
2079               NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 150, 4, 0, READ_LOCK)) &&
2080               NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 150, 4)) &&
2081               test_cli_read(cli2, fnum2, buf, 150, 4, NULL, 4) &&
2082               !(NT_STATUS_IS_OK(cli_writeall(cli2, fnum2, 0, (uint8_t *)buf,
2083                                              150, 4, NULL))) &&
2084               NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 150, 4));
2085         EXPECTED(ret, True);
2086         printf("this server %s do recursive lock overlays\n", ret?"does":"doesn't");
2087
2088         ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 160, 4, 0, READ_LOCK)) &&
2089               NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 160, 4)) &&
2090               NT_STATUS_IS_OK(cli_writeall(cli2, fnum2, 0, (uint8_t *)buf,
2091                                            160, 4, NULL)) &&
2092               test_cli_read(cli2, fnum2, buf, 160, 4, NULL, 4);
2093         EXPECTED(ret, True);
2094         printf("the same process %s remove a read lock using write locking\n", ret?"can":"cannot");
2095
2096         ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 170, 4, 0, WRITE_LOCK)) &&
2097               NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 170, 4)) &&
2098               NT_STATUS_IS_OK(cli_writeall(cli2, fnum2, 0, (uint8_t *)buf,
2099                                            170, 4, NULL)) &&
2100               test_cli_read(cli2, fnum2, buf, 170, 4, NULL, 4);
2101         EXPECTED(ret, True);
2102         printf("the same process %s remove a write lock using read locking\n", ret?"can":"cannot");
2103
2104         ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 190, 4, 0, WRITE_LOCK)) &&
2105               NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 190, 4, 0, READ_LOCK)) &&
2106               NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 190, 4)) &&
2107               !NT_STATUS_IS_OK(cli_writeall(cli2, fnum2, 0, (uint8_t *)buf,
2108                                             190, 4, NULL)) &&
2109               test_cli_read(cli2, fnum2, buf, 190, 4, NULL, 4);
2110         EXPECTED(ret, True);
2111         printf("the same process %s remove the first lock first\n", ret?"does":"doesn't");
2112
2113         cli_close(cli1, fnum1);
2114         cli_close(cli2, fnum2);
2115         cli_open(cli1, fname, O_RDWR, DENY_NONE, &fnum1);
2116         cli_open(cli1, fname, O_RDWR, DENY_NONE, &f);
2117         ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 0, 8, 0, READ_LOCK)) &&
2118               NT_STATUS_IS_OK(cli_lock32(cli1, f, 0, 1, 0, READ_LOCK)) &&
2119               NT_STATUS_IS_OK(cli_close(cli1, fnum1)) &&
2120               NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDWR, DENY_NONE, &fnum1)) &&
2121               NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 7, 1, 0, WRITE_LOCK));
2122         cli_close(cli1, f);
2123         cli_close(cli1, fnum1);
2124         EXPECTED(ret, True);
2125         printf("the server %s have the NT byte range lock bug\n", !ret?"does":"doesn't");
2126
2127  fail:
2128         cli_close(cli1, fnum1);
2129         cli_close(cli2, fnum2);
2130         cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
2131         torture_close_connection(cli1);
2132         torture_close_connection(cli2);
2133
2134         printf("finished locktest4\n");
2135         return correct;
2136 }
2137
2138 /*
2139   looks at lock upgrade/downgrade.
2140 */
2141 static bool run_locktest5(int dummy)
2142 {
2143         static struct cli_state *cli1, *cli2;
2144         const char *fname = "\\lockt5.lck";
2145         uint16_t fnum1, fnum2, fnum3;
2146         bool ret;
2147         char buf[1000];
2148         bool correct = True;
2149         NTSTATUS status;
2150
2151         if (!torture_open_connection(&cli1, 0) || !torture_open_connection(&cli2, 1)) {
2152                 return False;
2153         }
2154
2155         cli_sockopt(cli1, sockops);
2156         cli_sockopt(cli2, sockops);
2157
2158         printf("starting locktest5\n");
2159
2160         cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
2161
2162         cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1);
2163         cli_open(cli2, fname, O_RDWR, DENY_NONE, &fnum2);
2164         cli_open(cli1, fname, O_RDWR, DENY_NONE, &fnum3);
2165
2166         memset(buf, 0, sizeof(buf));
2167
2168         status = cli_writeall(cli1, fnum1, 0, (uint8_t *)buf, 0, sizeof(buf),
2169                               NULL);
2170         if (!NT_STATUS_IS_OK(status)) {
2171                 printf("Failed to create file: %s\n", nt_errstr(status));
2172                 correct = False;
2173                 goto fail;
2174         }
2175
2176         /* Check for NT bug... */
2177         ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 0, 8, 0, READ_LOCK)) &&
2178               NT_STATUS_IS_OK(cli_lock32(cli1, fnum3, 0, 1, 0, READ_LOCK));
2179         cli_close(cli1, fnum1);
2180         cli_open(cli1, fname, O_RDWR, DENY_NONE, &fnum1);
2181         status = cli_lock32(cli1, fnum1, 7, 1, 0, WRITE_LOCK);
2182         ret = NT_STATUS_IS_OK(status);
2183         EXPECTED(ret, True);
2184         printf("this server %s the NT locking bug\n", ret ? "doesn't have" : "has");
2185         cli_close(cli1, fnum1);
2186         cli_open(cli1, fname, O_RDWR, DENY_NONE, &fnum1);
2187         cli_unlock(cli1, fnum3, 0, 1);
2188
2189         ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 0, 4, 0, WRITE_LOCK)) &&
2190               NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 1, 1, 0, READ_LOCK));
2191         EXPECTED(ret, True);
2192         printf("the same process %s overlay a write with a read lock\n", ret?"can":"cannot");
2193
2194         status = cli_lock32(cli2, fnum2, 0, 4, 0, READ_LOCK);
2195         ret = NT_STATUS_IS_OK(status);
2196         EXPECTED(ret, False);
2197
2198         printf("a different processs %s get a read lock on the first process lock stack\n", ret?"can":"cannot");
2199
2200         /* Unlock the process 2 lock. */
2201         cli_unlock(cli2, fnum2, 0, 4);
2202
2203         status = cli_lock32(cli1, fnum3, 0, 4, 0, READ_LOCK);
2204         ret = NT_STATUS_IS_OK(status);
2205         EXPECTED(ret, False);
2206
2207         printf("the same processs on a different fnum %s get a read lock\n", ret?"can":"cannot");
2208
2209         /* Unlock the process 1 fnum3 lock. */
2210         cli_unlock(cli1, fnum3, 0, 4);
2211
2212         /* Stack 2 more locks here. */
2213         ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 0, 4, 0, READ_LOCK)) &&
2214               NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 0, 4, 0, READ_LOCK));
2215
2216         EXPECTED(ret, True);
2217         printf("the same process %s stack read locks\n", ret?"can":"cannot");
2218
2219         /* Unlock the first process lock, then check this was the WRITE lock that was
2220                 removed. */
2221
2222         ret = NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 0, 4)) &&
2223               NT_STATUS_IS_OK(cli_lock32(cli2, fnum2, 0, 4, 0, READ_LOCK));
2224
2225         EXPECTED(ret, True);
2226         printf("the first unlock removes the %s lock\n", ret?"WRITE":"READ");
2227
2228         /* Unlock the process 2 lock. */
2229         cli_unlock(cli2, fnum2, 0, 4);
2230
2231         /* We should have 3 stacked locks here. Ensure we need to do 3 unlocks. */
2232
2233         ret = NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 1, 1)) &&
2234                   NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 0, 4)) &&
2235                   NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 0, 4));
2236
2237         EXPECTED(ret, True);
2238         printf("the same process %s unlock the stack of 4 locks\n", ret?"can":"cannot");
2239
2240         /* Ensure the next unlock fails. */
2241         ret = NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 0, 4));
2242         EXPECTED(ret, False);
2243         printf("the same process %s count the lock stack\n", !ret?"can":"cannot");
2244
2245         /* Ensure connection 2 can get a write lock. */
2246         status = cli_lock32(cli2, fnum2, 0, 4, 0, WRITE_LOCK);
2247         ret = NT_STATUS_IS_OK(status);
2248         EXPECTED(ret, True);
2249
2250         printf("a different processs %s get a write lock on the unlocked stack\n", ret?"can":"cannot");
2251
2252
2253  fail:
2254         cli_close(cli1, fnum1);
2255         cli_close(cli2, fnum2);
2256         cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
2257         if (!torture_close_connection(cli1)) {
2258                 correct = False;
2259         }
2260         if (!torture_close_connection(cli2)) {
2261                 correct = False;
2262         }
2263
2264         printf("finished locktest5\n");
2265
2266         return correct;
2267 }
2268
2269 /*
2270   tries the unusual lockingX locktype bits
2271 */
2272 static bool run_locktest6(int dummy)
2273 {
2274         static struct cli_state *cli;
2275         const char *fname[1] = { "\\lock6.txt" };
2276         int i;
2277         uint16_t fnum;
2278         NTSTATUS status;
2279
2280         if (!torture_open_connection(&cli, 0)) {
2281                 return False;
2282         }
2283
2284         cli_sockopt(cli, sockops);
2285
2286         printf("starting locktest6\n");
2287
2288         for (i=0;i<1;i++) {
2289                 printf("Testing %s\n", fname[i]);
2290
2291                 cli_unlink(cli, fname[i], FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
2292
2293                 cli_open(cli, fname[i], O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum);
2294                 status = cli_locktype(cli, fnum, 0, 8, 0, LOCKING_ANDX_CHANGE_LOCKTYPE);
2295                 cli_close(cli, fnum);
2296                 printf("CHANGE_LOCKTYPE gave %s\n", nt_errstr(status));
2297
2298                 cli_open(cli, fname[i], O_RDWR, DENY_NONE, &fnum);
2299                 status = cli_locktype(cli, fnum, 0, 8, 0, LOCKING_ANDX_CANCEL_LOCK);
2300                 cli_close(cli, fnum);
2301                 printf("CANCEL_LOCK gave %s\n", nt_errstr(status));
2302
2303                 cli_unlink(cli, fname[i], FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
2304         }
2305
2306         torture_close_connection(cli);
2307
2308         printf("finished locktest6\n");
2309         return True;
2310 }
2311
2312 static bool run_locktest7(int dummy)
2313 {
2314         struct cli_state *cli1;
2315         const char *fname = "\\lockt7.lck";
2316         uint16_t fnum1;
2317         char buf[200];
2318         bool correct = False;
2319         size_t nread;
2320         NTSTATUS status;
2321
2322         if (!torture_open_connection(&cli1, 0)) {
2323                 return False;
2324         }
2325
2326         cli_sockopt(cli1, sockops);
2327
2328         printf("starting locktest7\n");
2329
2330         cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
2331
2332         cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1);
2333
2334         memset(buf, 0, sizeof(buf));
2335
2336         status = cli_writeall(cli1, fnum1, 0, (uint8_t *)buf, 0, sizeof(buf),
2337                               NULL);
2338         if (!NT_STATUS_IS_OK(status)) {
2339                 printf("Failed to create file: %s\n", nt_errstr(status));
2340                 goto fail;
2341         }
2342
2343         cli_setpid(cli1, 1);
2344
2345         status = cli_lock32(cli1, fnum1, 130, 4, 0, READ_LOCK);
2346         if (!NT_STATUS_IS_OK(status)) {
2347                 printf("Unable to apply read lock on range 130:4, "
2348                        "error was %s\n", nt_errstr(status));
2349                 goto fail;
2350         } else {
2351                 printf("pid1 successfully locked range 130:4 for READ\n");
2352         }
2353
2354         status = cli_read(cli1, fnum1, buf, 130, 4, &nread);
2355         if (!NT_STATUS_IS_OK(status)) {
2356                 printf("pid1 unable to read the range 130:4, error was %s\n",
2357                       nt_errstr(status));
2358                 goto fail;
2359         } else if (nread != 4) {
2360                 printf("pid1 unable to read the range 130:4, "
2361                        "recv %ld req %d\n", (unsigned long)nread, 4);
2362                 goto fail;
2363         } else {
2364                 printf("pid1 successfully read the range 130:4\n");
2365         }
2366
2367         status = cli_writeall(cli1, fnum1, 0, (uint8_t *)buf, 130, 4, NULL);
2368         if (!NT_STATUS_IS_OK(status)) {
2369                 printf("pid1 unable to write to the range 130:4, error was "
2370                        "%s\n", nt_errstr(status));
2371                 if (!NT_STATUS_EQUAL(status, NT_STATUS_FILE_LOCK_CONFLICT)) {
2372                         printf("Incorrect error (should be NT_STATUS_FILE_LOCK_CONFLICT)\n");
2373                         goto fail;
2374                 }
2375         } else {
2376                 printf("pid1 successfully wrote to the range 130:4 (should be denied)\n");
2377                 goto fail;
2378         }
2379
2380         cli_setpid(cli1, 2);
2381
2382         status = cli_read(cli1, fnum1, buf, 130, 4, &nread);
2383         if (!NT_STATUS_IS_OK(status)) {
2384                 printf("pid2 unable to read the range 130:4, error was %s\n",
2385                       nt_errstr(status));
2386                 goto fail;
2387         } else if (nread != 4) {
2388                 printf("pid2 unable to read the range 130:4, "
2389                        "recv %ld req %d\n", (unsigned long)nread, 4);
2390                 goto fail;
2391         } else {
2392                 printf("pid2 successfully read the range 130:4\n");
2393         }
2394
2395         status = cli_writeall(cli1, fnum1, 0, (uint8_t *)buf, 130, 4, NULL);
2396         if (!NT_STATUS_IS_OK(status)) {
2397                 printf("pid2 unable to write to the range 130:4, error was "
2398                        "%s\n", nt_errstr(status));
2399                 if (!NT_STATUS_EQUAL(status, NT_STATUS_FILE_LOCK_CONFLICT)) {
2400                         printf("Incorrect error (should be NT_STATUS_FILE_LOCK_CONFLICT)\n");
2401                         goto fail;
2402                 }
2403         } else {
2404                 printf("pid2 successfully wrote to the range 130:4 (should be denied)\n");
2405                 goto fail;
2406         }
2407
2408         cli_setpid(cli1, 1);
2409         cli_unlock(cli1, fnum1, 130, 4);
2410
2411         status = cli_lock32(cli1, fnum1, 130, 4, 0, WRITE_LOCK);
2412         if (!NT_STATUS_IS_OK(status)) {
2413                 printf("Unable to apply write lock on range 130:4, error was %s\n", nt_errstr(status));
2414                 goto fail;
2415         } else {
2416                 printf("pid1 successfully locked range 130:4 for WRITE\n");
2417         }
2418
2419         status = cli_read(cli1, fnum1, buf, 130, 4, &nread);
2420         if (!NT_STATUS_IS_OK(status)) {
2421                 printf("pid1 unable to read the range 130:4, error was %s\n",
2422                       nt_errstr(status));
2423                 goto fail;
2424         } else if (nread != 4) {
2425                 printf("pid1 unable to read the range 130:4, "
2426                        "recv %ld req %d\n", (unsigned long)nread, 4);
2427                 goto fail;
2428         } else {
2429                 printf("pid1 successfully read the range 130:4\n");
2430         }
2431
2432         status = cli_writeall(cli1, fnum1, 0, (uint8_t *)buf, 130, 4, NULL);
2433         if (!NT_STATUS_IS_OK(status)) {
2434                 printf("pid1 unable to write to the range 130:4, error was "
2435                        "%s\n", nt_errstr(status));
2436                 goto fail;
2437         } else {
2438                 printf("pid1 successfully wrote to the range 130:4\n");
2439         }
2440
2441         cli_setpid(cli1, 2);
2442
2443         status = cli_read(cli1, fnum1, buf, 130, 4, &nread);
2444         if (!NT_STATUS_IS_OK(status)) {
2445                 printf("pid2 unable to read the range 130:4, error was "
2446                        "%s\n", nt_errstr(status));
2447                 if (!NT_STATUS_EQUAL(status, NT_STATUS_FILE_LOCK_CONFLICT)) {
2448                         printf("Incorrect error (should be NT_STATUS_FILE_LOCK_CONFLICT)\n");
2449                         goto fail;
2450                 }
2451         } else {
2452                 printf("pid2 successfully read the range 130:4 (should be denied) recv %ld\n",
2453                        (unsigned long)nread);
2454                 goto fail;
2455         }
2456
2457         status = cli_writeall(cli1, fnum1, 0, (uint8_t *)buf, 130, 4, NULL);
2458         if (!NT_STATUS_IS_OK(status)) {
2459                 printf("pid2 unable to write to the range 130:4, error was "
2460                        "%s\n", nt_errstr(status));
2461                 if (!NT_STATUS_EQUAL(status, NT_STATUS_FILE_LOCK_CONFLICT)) {
2462                         printf("Incorrect error (should be NT_STATUS_FILE_LOCK_CONFLICT)\n");
2463                         goto fail;
2464                 }
2465         } else {
2466                 printf("pid2 successfully wrote to the range 130:4 (should be denied)\n");
2467                 goto fail;
2468         }
2469
2470         cli_unlock(cli1, fnum1, 130, 0);
2471         correct = True;
2472
2473 fail:
2474         cli_close(cli1, fnum1);
2475         cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
2476         torture_close_connection(cli1);
2477
2478         printf("finished locktest7\n");
2479         return correct;
2480 }
2481
2482 /*
2483  * This demonstrates a problem with our use of GPFS share modes: A file
2484  * descriptor sitting in the pending close queue holding a GPFS share mode
2485  * blocks opening a file another time. Happens with Word 2007 temp files.
2486  * With "posix locking = yes" and "gpfs:sharemodes = yes" enabled, the third
2487  * open is denied with NT_STATUS_SHARING_VIOLATION.
2488  */
2489
2490 static bool run_locktest8(int dummy)
2491 {
2492         struct cli_state *cli1;
2493         const char *fname = "\\lockt8.lck";
2494         uint16_t fnum1, fnum2;
2495         char buf[200];
2496         bool correct = False;
2497         NTSTATUS status;
2498
2499         if (!torture_open_connection(&cli1, 0)) {
2500                 return False;
2501         }
2502
2503         cli_sockopt(cli1, sockops);
2504
2505         printf("starting locktest8\n");
2506
2507         cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
2508
2509         status = cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_WRITE,
2510                           &fnum1);
2511         if (!NT_STATUS_IS_OK(status)) {
2512                 d_fprintf(stderr, "cli_open returned %s\n", nt_errstr(status));
2513                 return false;
2514         }
2515
2516         memset(buf, 0, sizeof(buf));
2517
2518         status = cli_open(cli1, fname, O_RDONLY, DENY_NONE, &fnum2);
2519         if (!NT_STATUS_IS_OK(status)) {
2520                 d_fprintf(stderr, "cli_open second time returned %s\n",
2521                           nt_errstr(status));
2522                 goto fail;
2523         }
2524
2525         status = cli_lock32(cli1, fnum2, 1, 1, 0, READ_LOCK);
2526         if (!NT_STATUS_IS_OK(status)) {
2527                 printf("Unable to apply read lock on range 1:1, error was "
2528                        "%s\n", nt_errstr(status));
2529                 goto fail;
2530         }
2531
2532         status = cli_close(cli1, fnum1);
2533         if (!NT_STATUS_IS_OK(status)) {
2534                 d_fprintf(stderr, "cli_close(fnum1) %s\n", nt_errstr(status));
2535                 goto fail;
2536         }
2537
2538         status = cli_open(cli1, fname, O_RDWR, DENY_NONE, &fnum1);
2539         if (!NT_STATUS_IS_OK(status)) {
2540                 d_fprintf(stderr, "cli_open third time returned %s\n",
2541                           nt_errstr(status));
2542                 goto fail;
2543         }
2544
2545         correct = true;
2546
2547 fail:
2548         cli_close(cli1, fnum1);
2549         cli_close(cli1, fnum2);
2550         cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
2551         torture_close_connection(cli1);
2552
2553         printf("finished locktest8\n");
2554         return correct;
2555 }
2556
2557 /*
2558  * This test is designed to be run in conjunction with
2559  * external NFS or POSIX locks taken in the filesystem.
2560  * It checks that the smbd server will block until the
2561  * lock is released and then acquire it. JRA.
2562  */
2563
2564 static bool got_alarm;
2565 static struct cli_state *alarm_cli;
2566
2567 static void alarm_handler(int dummy)
2568 {
2569         got_alarm = True;
2570 }
2571
2572 static void alarm_handler_parent(int dummy)
2573 {
2574         cli_state_disconnect(alarm_cli);
2575 }
2576
2577 static void do_local_lock(int read_fd, int write_fd)
2578 {
2579         int fd;
2580         char c = '\0';
2581         struct flock lock;
2582         const char *local_pathname = NULL;
2583         int ret;
2584
2585         local_pathname = talloc_asprintf(talloc_tos(),
2586                         "%s/lockt9.lck", local_path);
2587         if (!local_pathname) {
2588                 printf("child: alloc fail\n");
2589                 exit(1);
2590         }
2591
2592         unlink(local_pathname);
2593         fd = open(local_pathname, O_RDWR|O_CREAT, 0666);
2594         if (fd == -1) {
2595                 printf("child: open of %s failed %s.\n",
2596                         local_pathname, strerror(errno));
2597                 exit(1);
2598         }
2599
2600         /* Now take a fcntl lock. */
2601         lock.l_type = F_WRLCK;
2602         lock.l_whence = SEEK_SET;
2603         lock.l_start = 0;
2604         lock.l_len = 4;
2605         lock.l_pid = getpid();
2606
2607         ret = fcntl(fd,F_SETLK,&lock);
2608         if (ret == -1) {
2609                 printf("child: failed to get lock 0:4 on file %s. Error %s\n",
2610                         local_pathname, strerror(errno));
2611                 exit(1);
2612         } else {
2613                 printf("child: got lock 0:4 on file %s.\n",
2614                         local_pathname );
2615                 fflush(stdout);
2616         }
2617
2618         CatchSignal(SIGALRM, alarm_handler);
2619         alarm(5);
2620         /* Signal the parent. */
2621         if (write(write_fd, &c, 1) != 1) {
2622                 printf("child: start signal fail %s.\n",
2623                         strerror(errno));
2624                 exit(1);
2625         }
2626         alarm(0);
2627
2628         alarm(10);
2629         /* Wait for the parent to be ready. */
2630         if (read(read_fd, &c, 1) != 1) {
2631                 printf("child: reply signal fail %s.\n",
2632                         strerror(errno));
2633                 exit(1);
2634         }
2635         alarm(0);
2636
2637         sleep(5);
2638         close(fd);
2639         printf("child: released lock 0:4 on file %s.\n",
2640                 local_pathname );
2641         fflush(stdout);
2642         exit(0);
2643 }
2644
2645 static bool run_locktest9(int dummy)
2646 {
2647         struct cli_state *cli1;
2648         const char *fname = "\\lockt9.lck";
2649         uint16_t fnum;
2650         bool correct = False;
2651         int pipe_in[2], pipe_out[2];
2652         pid_t child_pid;
2653         char c = '\0';
2654         int ret;
2655         struct timeval start;
2656         double seconds;
2657         NTSTATUS status;
2658
2659         printf("starting locktest9\n");
2660
2661         if (local_path == NULL) {
2662                 d_fprintf(stderr, "locktest9 must be given a local path via -l <localpath>\n");
2663                 return false;
2664         }
2665
2666         if (pipe(pipe_in) == -1 || pipe(pipe_out) == -1) {
2667                 return false;
2668         }
2669
2670         child_pid = fork();
2671         if (child_pid == -1) {
2672                 return false;
2673         }
2674
2675         if (child_pid == 0) {
2676                 /* Child. */
2677                 do_local_lock(pipe_out[0], pipe_in[1]);
2678                 exit(0);
2679         }
2680
2681         close(pipe_out[0]);
2682         close(pipe_in[1]);
2683         pipe_out[0] = -1;
2684         pipe_in[1] = -1;
2685
2686         /* Parent. */
2687         ret = read(pipe_in[0], &c, 1);
2688         if (ret != 1) {
2689                 d_fprintf(stderr, "failed to read start signal from child. %s\n",
2690                         strerror(errno));
2691                 return false;
2692         }
2693
2694         if (!torture_open_connection(&cli1, 0)) {
2695                 return false;
2696         }
2697
2698         cli_sockopt(cli1, sockops);
2699
2700         status = cli_open(cli1, fname, O_RDWR, DENY_NONE,
2701                           &fnum);
2702         if (!NT_STATUS_IS_OK(status)) {
2703                 d_fprintf(stderr, "cli_open returned %s\n", nt_errstr(status));
2704                 return false;
2705         }
2706
2707         /* Ensure the child has the lock. */
2708         status = cli_lock32(cli1, fnum, 0, 4, 0, WRITE_LOCK);
2709         if (NT_STATUS_IS_OK(status)) {
2710                 d_fprintf(stderr, "Got the lock on range 0:4 - this should not happen !\n");
2711                 goto fail;
2712         } else {
2713                 d_printf("Child has the lock.\n");
2714         }
2715
2716         /* Tell the child to wait 5 seconds then exit. */
2717         ret = write(pipe_out[1], &c, 1);
2718         if (ret != 1) {
2719                 d_fprintf(stderr, "failed to send exit signal to child. %s\n",
2720                         strerror(errno));
2721                 goto fail;
2722         }
2723
2724         /* Wait 20 seconds for the lock. */
2725         alarm_cli = cli1;
2726         CatchSignal(SIGALRM, alarm_handler_parent);
2727         alarm(20);
2728
2729         start = timeval_current();
2730
2731         status = cli_lock32(cli1, fnum, 0, 4, -1, WRITE_LOCK);
2732         if (!NT_STATUS_IS_OK(status)) {
2733                 d_fprintf(stderr, "Unable to apply write lock on range 0:4, error was "
2734                        "%s\n", nt_errstr(status));
2735                 goto fail_nofd;
2736         }
2737         alarm(0);
2738
2739         seconds = timeval_elapsed(&start);
2740
2741         printf("Parent got the lock after %.2f seconds.\n",
2742                 seconds);
2743
2744         status = cli_close(cli1, fnum);
2745         if (!NT_STATUS_IS_OK(status)) {
2746                 d_fprintf(stderr, "cli_close(fnum1) %s\n", nt_errstr(status));
2747                 goto fail;
2748         }
2749
2750         correct = true;
2751
2752 fail:
2753         cli_close(cli1, fnum);
2754         torture_close_connection(cli1);
2755
2756 fail_nofd:
2757
2758         printf("finished locktest9\n");
2759         return correct;
2760 }
2761
2762 /*
2763 test whether fnums and tids open on one VC are available on another (a major
2764 security hole)
2765 */
2766 static bool run_fdpasstest(int dummy)
2767 {
2768         struct cli_state *cli1, *cli2;
2769         const char *fname = "\\fdpass.tst";
2770         uint16_t fnum1;
2771         char buf[1024];
2772         NTSTATUS status;
2773
2774         if (!torture_open_connection(&cli1, 0) || !torture_open_connection(&cli2, 1)) {
2775                 return False;
2776         }
2777         cli_sockopt(cli1, sockops);
2778         cli_sockopt(cli2, sockops);
2779
2780         printf("starting fdpasstest\n");
2781
2782         cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
2783
2784         status = cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE,
2785                           &fnum1);
2786         if (!NT_STATUS_IS_OK(status)) {
2787                 printf("open of %s failed (%s)\n", fname, nt_errstr(status));
2788                 return False;
2789         }
2790
2791         status = cli_writeall(cli1, fnum1, 0, (const uint8_t *)"hello world\n", 0,
2792                               13, NULL);
2793         if (!NT_STATUS_IS_OK(status)) {
2794                 printf("write failed (%s)\n", nt_errstr(status));
2795                 return False;
2796         }
2797
2798         cli_state_set_uid(cli2, cli_state_get_uid(cli1));
2799         cli_state_set_tid(cli2, cli_state_get_tid(cli1));
2800         cli_setpid(cli2, cli_getpid(cli1));
2801
2802         if (test_cli_read(cli2, fnum1, buf, 0, 13, NULL, 13)) {
2803                 printf("read succeeded! nasty security hole [%s]\n", buf);
2804                 return false;
2805         }
2806
2807         cli_close(cli1, fnum1);
2808         cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
2809
2810         torture_close_connection(cli1);
2811         torture_close_connection(cli2);
2812
2813         printf("finished fdpasstest\n");
2814         return True;
2815 }
2816
2817 static bool run_fdsesstest(int dummy)
2818 {
2819         struct cli_state *cli;
2820         uint16 new_vuid;
2821         uint16 saved_vuid;
2822         uint16 new_cnum;
2823         uint16 saved_cnum;
2824         const char *fname = "\\fdsess.tst";
2825         const char *fname1 = "\\fdsess1.tst";
2826         uint16_t fnum1;
2827         uint16_t fnum2;
2828         char buf[1024];
2829         bool ret = True;
2830         NTSTATUS status;
2831
2832         if (!torture_open_connection(&cli, 0))
2833                 return False;
2834         cli_sockopt(cli, sockops);
2835
2836         if (!torture_cli_session_setup2(cli, &new_vuid))
2837                 return False;
2838
2839         saved_cnum = cli_state_get_tid(cli);
2840         if (!NT_STATUS_IS_OK(cli_tcon_andx(cli, share, "?????", "", 1)))
2841                 return False;
2842         new_cnum = cli_state_get_tid(cli);
2843         cli_state_set_tid(cli, saved_cnum);
2844
2845         printf("starting fdsesstest\n");
2846
2847         cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
2848         cli_unlink(cli, fname1, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
2849
2850         status = cli_open(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1);
2851         if (!NT_STATUS_IS_OK(status)) {
2852                 printf("open of %s failed (%s)\n", fname, nt_errstr(status));
2853                 return False;
2854         }
2855
2856         status = cli_writeall(cli, fnum1, 0, (const uint8_t *)"hello world\n", 0, 13,
2857                               NULL);
2858         if (!NT_STATUS_IS_OK(status)) {
2859                 printf("write failed (%s)\n", nt_errstr(status));
2860                 return False;
2861         }
2862
2863         saved_vuid = cli_state_get_uid(cli);
2864         cli_state_set_uid(cli, new_vuid);
2865
2866         if (test_cli_read(cli, fnum1, buf, 0, 13, NULL, 13)) {
2867                 printf("read succeeded with different vuid! "
2868                        "nasty security hole [%s]\n", buf);
2869                 ret = false;
2870         }
2871         /* Try to open a file with different vuid, samba cnum. */
2872         if (NT_STATUS_IS_OK(cli_open(cli, fname1, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum2))) {
2873                 printf("create with different vuid, same cnum succeeded.\n");
2874                 cli_close(cli, fnum2);
2875                 cli_unlink(cli, fname1, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
2876         } else {
2877                 printf("create with different vuid, same cnum failed.\n");
2878                 printf("This will cause problems with service clients.\n");
2879                 ret = False;
2880         }
2881
2882         cli_state_set_uid(cli, saved_vuid);
2883
2884         /* Try with same vuid, different cnum. */
2885         cli_state_set_tid(cli, new_cnum);
2886
2887         if (test_cli_read(cli, fnum1, buf, 0, 13, NULL, 13)) {
2888                 printf("read succeeded with different cnum![%s]\n", buf);
2889                 ret = false;
2890         }
2891
2892         cli_state_set_tid(cli, saved_cnum);
2893         cli_close(cli, fnum1);
2894         cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
2895
2896         torture_close_connection(cli);
2897
2898         printf("finished fdsesstest\n");
2899         return ret;
2900 }
2901
2902 /*
2903   This test checks that
2904
2905   1) the server does not allow an unlink on a file that is open
2906 */
2907 static bool run_unlinktest(int dummy)
2908 {
2909         struct cli_state *cli;
2910         const char *fname = "\\unlink.tst";
2911         uint16_t fnum;
2912         bool correct = True;
2913         NTSTATUS status;
2914
2915         if (!torture_open_connection(&cli, 0)) {
2916                 return False;
2917         }
2918
2919         cli_sockopt(cli, sockops);
2920
2921         printf("starting unlink test\n");
2922
2923         cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
2924
2925         cli_setpid(cli, 1);
2926
2927         status = cli_open(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum);
2928         if (!NT_STATUS_IS_OK(status)) {
2929                 printf("open of %s failed (%s)\n", fname, nt_errstr(status));
2930                 return False;
2931         }
2932
2933         status = cli_unlink(cli, fname,
2934                             FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
2935         if (NT_STATUS_IS_OK(status)) {
2936                 printf("error: server allowed unlink on an open file\n");
2937                 correct = False;
2938         } else {
2939                 correct = check_error(__LINE__, status, ERRDOS, ERRbadshare,
2940                                       NT_STATUS_SHARING_VIOLATION);
2941         }
2942
2943         cli_close(cli, fnum);
2944         cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
2945
2946         if (!torture_close_connection(cli)) {
2947                 correct = False;
2948         }
2949
2950         printf("unlink test finished\n");
2951
2952         return correct;
2953 }
2954
2955
2956 /*
2957 test how many open files this server supports on the one socket
2958 */
2959 static bool run_maxfidtest(int dummy)
2960 {
2961         struct cli_state *cli;
2962         fstring fname;
2963         uint16_t fnums[0x11000];
2964         int i;
2965         int retries=4;
2966         bool correct = True;
2967         NTSTATUS status;
2968
2969         cli = current_cli;
2970
2971         if (retries <= 0) {
2972                 printf("failed to connect\n");
2973                 return False;
2974         }
2975
2976         cli_sockopt(cli, sockops);
2977
2978         for (i=0; i<0x11000; i++) {
2979                 slprintf(fname,sizeof(fname)-1,"\\maxfid.%d.%d", i,(int)getpid());
2980                 status = cli_open(cli, fname, O_RDWR|O_CREAT|O_TRUNC, DENY_NONE,
2981                                   &fnums[i]);
2982                 if (!NT_STATUS_IS_OK(status)) {
2983                         printf("open of %s failed (%s)\n",
2984                                fname, nt_errstr(status));
2985                         printf("maximum fnum is %d\n", i);
2986                         break;
2987                 }
2988                 printf("%6d\r", i);
2989         }
2990         printf("%6d\n", i);
2991         i--;
2992
2993         printf("cleaning up\n");
2994         for (;i>=0;i--) {
2995                 slprintf(fname,sizeof(fname)-1,"\\maxfid.%d.%d", i,(int)getpid());
2996                 cli_close(cli, fnums[i]);
2997
2998                 status = cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
2999                 if (!NT_STATUS_IS_OK(status)) {
3000                         printf("unlink of %s failed (%s)\n",
3001                                fname, nt_errstr(status));
3002                         correct = False;
3003                 }
3004                 printf("%6d\r", i);
3005         }
3006         printf("%6d\n", 0);
3007
3008         printf("maxfid test finished\n");
3009         if (!torture_close_connection(cli)) {
3010                 correct = False;
3011         }
3012         return correct;
3013 }
3014
3015 /* generate a random buffer */
3016 static void rand_buf(char *buf, int len)
3017 {
3018         while (len--) {
3019                 *buf = (char)sys_random();
3020                 buf++;
3021         }
3022 }
3023
3024 /* send smb negprot commands, not reading the response */
3025 static bool run_negprot_nowait(int dummy)
3026 {
3027         struct tevent_context *ev;
3028         int i;
3029         struct cli_state *cli;
3030         bool correct = True;
3031
3032         printf("starting negprot nowait test\n");
3033
3034         ev = tevent_context_init(talloc_tos());
3035         if (ev == NULL) {
3036                 return false;
3037         }
3038
3039         if (!(cli = open_nbt_connection())) {
3040                 TALLOC_FREE(ev);
3041                 return False;
3042         }
3043
3044         for (i=0;i<50000;i++) {
3045                 struct tevent_req *req;
3046
3047                 req = cli_negprot_send(ev, ev, cli);
3048                 if (req == NULL) {
3049                         TALLOC_FREE(ev);
3050                         return false;
3051                 }
3052                 if (!tevent_req_poll(req, ev)) {
3053                         d_fprintf(stderr, "tevent_req_poll failed: %s\n",
3054                                   strerror(errno));
3055                         TALLOC_FREE(ev);
3056                         return false;
3057                 }
3058                 TALLOC_FREE(req);
3059         }
3060
3061         if (torture_close_connection(cli)) {
3062                 correct = False;
3063         }
3064
3065         printf("finished negprot nowait test\n");
3066
3067         return correct;
3068 }
3069
3070 /* send smb negprot commands, not reading the response */
3071 static bool run_bad_nbt_session(int dummy)
3072 {
3073         struct nmb_name called, calling;
3074         struct sockaddr_storage ss;
3075         NTSTATUS status;
3076         int fd;
3077         bool ret;
3078
3079         printf("starting bad nbt session test\n");
3080
3081         make_nmb_name(&calling, myname, 0x0);
3082         make_nmb_name(&called , host, 0x20);
3083
3084         if (!resolve_name(host, &ss, 0x20, true)) {
3085                 d_fprintf(stderr, "Could not resolve name %s\n", host);
3086                 return false;
3087         }
3088
3089         status = open_socket_out(&ss, 139, 10000, &fd);
3090         if (!NT_STATUS_IS_OK(status)) {
3091                 d_fprintf(stderr, "open_socket_out failed: %s\n",
3092                           nt_errstr(status));
3093                 return false;
3094         }
3095
3096         ret = cli_bad_session_request(fd, &calling, &called);
3097         close(fd);
3098         if (!ret) {
3099                 d_fprintf(stderr, "open_socket_out failed: %s\n",
3100                           nt_errstr(status));
3101                 return false;
3102         }
3103
3104         printf("finished bad nbt session test\n");
3105         return true;
3106 }
3107
3108 /* send random IPC commands */
3109 static bool run_randomipc(int dummy)
3110 {
3111         char *rparam = NULL;
3112         char *rdata = NULL;
3113         unsigned int rdrcnt,rprcnt;
3114         char param[1024];
3115         int api, param_len, i;
3116         struct cli_state *cli;
3117         bool correct = True;
3118         int count = 50000;
3119
3120         printf("starting random ipc test\n");
3121
3122         if (!torture_open_connection(&cli, 0)) {
3123                 return False;
3124         }
3125
3126         for (i=0;i<count;i++) {
3127                 api = sys_random() % 500;
3128                 param_len = (sys_random() % 64);
3129
3130                 rand_buf(param, param_len);
3131
3132                 SSVAL(param,0,api);
3133
3134                 cli_api(cli,
3135                         param, param_len, 8,
3136                         NULL, 0, BUFFER_SIZE,
3137                         &rparam, &rprcnt,
3138                         &rdata, &rdrcnt);
3139                 if (i % 100 == 0) {
3140                         printf("%d/%d\r", i,count);
3141                 }
3142         }
3143         printf("%d/%d\n", i, count);
3144
3145         if (!torture_close_connection(cli)) {
3146                 correct = False;
3147         }
3148
3149         printf("finished random ipc test\n");
3150
3151         return correct;
3152 }
3153
3154
3155
3156 static void browse_callback(const char *sname, uint32 stype,
3157                             const char *comment, void *state)
3158 {
3159         printf("\t%20.20s %08x %s\n", sname, stype, comment);
3160 }
3161
3162
3163
3164 /*
3165   This test checks the browse list code
3166
3167 */
3168 static bool run_browsetest(int dummy)
3169 {
3170         static struct cli_state *cli;
3171         bool correct = True;
3172
3173         printf("starting browse test\n");
3174
3175         if (!torture_open_connection(&cli, 0)) {
3176                 return False;
3177         }
3178
3179         printf("domain list:\n");
3180         cli_NetServerEnum(cli, cli->server_domain,
3181                           SV_TYPE_DOMAIN_ENUM,
3182                           browse_callback, NULL);
3183
3184         printf("machine list:\n");
3185         cli_NetServerEnum(cli, cli->server_domain,
3186                           SV_TYPE_ALL,
3187                           browse_callback, NULL);
3188
3189         if (!torture_close_connection(cli)) {
3190                 correct = False;
3191         }
3192
3193         printf("browse test finished\n");
3194
3195         return correct;
3196
3197 }
3198
3199
3200 /*
3201   This checks how the getatr calls works
3202 */
3203 static bool run_attrtest(int dummy)
3204 {
3205         struct cli_state *cli;
3206         uint16_t fnum;
3207         time_t t, t2;
3208         const char *fname = "\\attrib123456789.tst";
3209         bool correct = True;
3210         NTSTATUS status;
3211
3212         printf("starting attrib test\n");
3213
3214         if (!torture_open_connection(&cli, 0)) {
3215                 return False;
3216         }
3217
3218         cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
3219         cli_open(cli, fname,
3220                         O_RDWR | O_CREAT | O_TRUNC, DENY_NONE, &fnum);
3221         cli_close(cli, fnum);
3222
3223         status = cli_getatr(cli, fname, NULL, NULL, &t);
3224         if (!NT_STATUS_IS_OK(status)) {
3225                 printf("getatr failed (%s)\n", nt_errstr(status));
3226                 correct = False;
3227         }
3228
3229         if (abs(t - time(NULL)) > 60*60*24*10) {
3230                 printf("ERROR: SMBgetatr bug. time is %s",
3231                        ctime(&t));
3232                 t = time(NULL);
3233                 correct = True;
3234         }
3235
3236         t2 = t-60*60*24; /* 1 day ago */
3237
3238         status = cli_setatr(cli, fname, 0, t2);
3239         if (!NT_STATUS_IS_OK(status)) {
3240                 printf("setatr failed (%s)\n", nt_errstr(status));
3241                 correct = True;
3242         }
3243
3244         status = cli_getatr(cli, fname, NULL, NULL, &t);
3245         if (!NT_STATUS_IS_OK(status)) {
3246                 printf("getatr failed (%s)\n", nt_errstr(status));
3247                 correct = True;
3248         }
3249
3250         if (t != t2) {
3251                 printf("ERROR: getatr/setatr bug. times are\n%s",
3252                        ctime(&t));
3253                 printf("%s", ctime(&t2));
3254                 correct = True;
3255         }
3256
3257         cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
3258
3259         if (!torture_close_connection(cli)) {
3260                 correct = False;
3261         }
3262
3263         printf("attrib test finished\n");
3264
3265         return correct;
3266 }
3267
3268
3269 /*
3270   This checks a couple of trans2 calls
3271 */
3272 static bool run_trans2test(int dummy)
3273 {
3274         struct cli_state *cli;
3275         uint16_t fnum;
3276         SMB_OFF_T size;
3277         time_t c_time, a_time, m_time;
3278         struct timespec c_time_ts, a_time_ts, m_time_ts, w_time_ts, m_time2_ts;
3279         const char *fname = "\\trans2.tst";
3280         const char *dname = "\\trans2";
3281         const char *fname2 = "\\trans2\\trans2.tst";
3282         char *pname;
3283         bool correct = True;
3284         NTSTATUS status;
3285         uint32_t fs_attr;
3286
3287         printf("starting trans2 test\n");
3288
3289         if (!torture_open_connection(&cli, 0)) {
3290                 return False;
3291         }
3292
3293         status = cli_get_fs_attr_info(cli, &fs_attr);
3294         if (!NT_STATUS_IS_OK(status)) {
3295                 printf("ERROR: cli_get_fs_attr_info returned %s\n",
3296                        nt_errstr(status));
3297                 correct = false;
3298         }
3299
3300         cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
3301         cli_open(cli, fname, O_RDWR | O_CREAT | O_TRUNC, DENY_NONE, &fnum);
3302         status = cli_qfileinfo_basic(cli, fnum, NULL, &size, &c_time_ts,
3303                                      &a_time_ts, &w_time_ts, &m_time_ts, NULL);
3304         if (!NT_STATUS_IS_OK(status)) {
3305                 printf("ERROR: qfileinfo failed (%s)\n", nt_errstr(status));
3306                 correct = False;
3307         }
3308
3309         status = cli_qfilename(cli, fnum, talloc_tos(), &pname);
3310         if (!NT_STATUS_IS_OK(status)) {
3311                 printf("ERROR: qfilename failed (%s)\n", nt_errstr(status));
3312                 correct = False;
3313         }
3314
3315         if (strcmp(pname, fname)) {
3316                 printf("qfilename gave different name? [%s] [%s]\n",
3317                        fname, pname);
3318                 correct = False;
3319         }
3320
3321         cli_close(cli, fnum);
3322
3323         sleep(2);
3324
3325         cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
3326         status = cli_open(cli, fname, O_RDWR | O_CREAT | O_TRUNC, DENY_NONE,
3327                           &fnum);
3328         if (!NT_STATUS_IS_OK(status)) {
3329                 printf("open of %s failed (%s)\n", fname, nt_errstr(status));
3330                 return False;
3331         }
3332         cli_close(cli, fnum);
3333
3334         status = cli_qpathinfo1(cli, fname, &c_time, &a_time, &m_time, &size,
3335                                 NULL);
3336         if (!NT_STATUS_IS_OK(status)) {
3337                 printf("ERROR: qpathinfo failed (%s)\n", nt_errstr(status));
3338                 correct = False;
3339         } else {
3340                 time_t t = time(NULL);
3341
3342                 if (c_time != m_time) {
3343                         printf("create time=%s", ctime(&c_time));
3344                         printf("modify time=%s", ctime(&m_time));
3345                         printf("This system appears to have sticky create times\n");
3346                 }
3347                 if ((abs(a_time - t) > 60) && (a_time % (60*60) == 0)) {
3348                         printf("access time=%s", ctime(&a_time));
3349                         printf("This system appears to set a midnight access time\n");
3350                         correct = False;
3351                 }
3352
3353                 if (abs(m_time - t) > 60*60*24*7) {
3354                         printf("ERROR: totally incorrect times - maybe word reversed? mtime=%s", ctime(&m_time));
3355                         correct = False;
3356                 }
3357         }
3358
3359
3360         cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
3361         cli_open(cli, fname,
3362                         O_RDWR | O_CREAT | O_TRUNC, DENY_NONE, &fnum);
3363         cli_close(cli, fnum);
3364         status = cli_qpathinfo2(cli, fname, &c_time_ts, &a_time_ts, &w_time_ts,
3365                                 &m_time_ts, &size, NULL, NULL);
3366         if (!NT_STATUS_IS_OK(status)) {
3367                 printf("ERROR: qpathinfo2 failed (%s)\n", nt_errstr(status));
3368                 correct = False;
3369         } else {
3370                 if (w_time_ts.tv_sec < 60*60*24*2) {
3371                         printf("write time=%s", ctime(&w_time_ts.tv_sec));
3372                         printf("This system appears to set a initial 0 write time\n");
3373                         correct = False;
3374                 }
3375         }
3376
3377         cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
3378
3379
3380         /* check if the server updates the directory modification time
3381            when creating a new file */
3382         status = cli_mkdir(cli, dname);
3383         if (!NT_STATUS_IS_OK(status)) {
3384                 printf("ERROR: mkdir failed (%s)\n", nt_errstr(status));
3385                 correct = False;
3386         }
3387         sleep(3);
3388         status = cli_qpathinfo2(cli, "\\trans2\\", &c_time_ts, &a_time_ts,
3389                                 &w_time_ts, &m_time_ts, &size, NULL, NULL);
3390         if (!NT_STATUS_IS_OK(status)) {
3391                 printf("ERROR: qpathinfo2 failed (%s)\n", nt_errstr(status));
3392                 correct = False;
3393         }
3394
3395         cli_open(cli, fname2,
3396                         O_RDWR | O_CREAT | O_TRUNC, DENY_NONE, &fnum);
3397         cli_writeall(cli, fnum,  0, (uint8_t *)&fnum, 0, sizeof(fnum), NULL);
3398         cli_close(cli, fnum);
3399         status = cli_qpathinfo2(cli, "\\trans2\\", &c_time_ts, &a_time_ts,
3400                                 &w_time_ts, &m_time2_ts, &size, NULL, NULL);
3401         if (!NT_STATUS_IS_OK(status)) {
3402                 printf("ERROR: qpathinfo2 failed (%s)\n", nt_errstr(status));
3403                 correct = False;
3404         } else {
3405                 if (memcmp(&m_time_ts, &m_time2_ts, sizeof(struct timespec))
3406                     == 0) {
3407                         printf("This system does not update directory modification times\n");
3408                         correct = False;
3409                 }
3410         }
3411         cli_unlink(cli, fname2, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
3412         cli_rmdir(cli, dname);
3413
3414         if (!torture_close_connection(cli)) {
3415                 correct = False;
3416         }
3417
3418         printf("trans2 test finished\n");
3419
3420         return correct;
3421 }
3422
3423 /*
3424   This checks new W2K calls.
3425 */
3426
3427 static NTSTATUS new_trans(struct cli_state *pcli, int fnum, int level)
3428 {
3429         uint8_t *buf = NULL;
3430         uint32 len;
3431         NTSTATUS status;
3432
3433         status = cli_qfileinfo(talloc_tos(), pcli, fnum, level, 0,
3434                                pcli->max_xmit, NULL, &buf, &len);
3435         if (!NT_STATUS_IS_OK(status)) {
3436                 printf("ERROR: qfileinfo (%d) failed (%s)\n", level,
3437                        nt_errstr(status));
3438         } else {
3439                 printf("qfileinfo: level %d, len = %u\n", level, len);
3440                 dump_data(0, (uint8 *)buf, len);
3441                 printf("\n");
3442         }
3443         TALLOC_FREE(buf);
3444         return status;
3445 }
3446
3447 static bool run_w2ktest(int dummy)
3448 {
3449         struct cli_state *cli;
3450         uint16_t fnum;
3451         const char *fname = "\\w2ktest\\w2k.tst";
3452         int level;
3453         bool correct = True;
3454
3455         printf("starting w2k test\n");
3456
3457         if (!torture_open_connection(&cli, 0)) {
3458                 return False;
3459         }
3460
3461         cli_open(cli, fname,
3462                         O_RDWR | O_CREAT , DENY_NONE, &fnum);
3463
3464         for (level = 1004; level < 1040; level++) {
3465                 new_trans(cli, fnum, level);
3466         }
3467
3468         cli_close(cli, fnum);
3469
3470         if (!torture_close_connection(cli)) {
3471                 correct = False;
3472         }
3473
3474         printf("w2k test finished\n");
3475
3476         return correct;
3477 }
3478
3479
3480 /*
3481   this is a harness for some oplock tests
3482  */
3483 static bool run_oplock1(int dummy)
3484 {
3485         struct cli_state *cli1;
3486         const char *fname = "\\lockt1.lck";
3487         uint16_t fnum1;
3488         bool correct = True;
3489         NTSTATUS status;
3490
3491         printf("starting oplock test 1\n");
3492
3493         if (!torture_open_connection(&cli1, 0)) {
3494                 return False;
3495         }
3496
3497         cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
3498
3499         cli_sockopt(cli1, sockops);
3500
3501         cli1->use_oplocks = True;
3502
3503         status = cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE,
3504                           &fnum1);
3505         if (!NT_STATUS_IS_OK(status)) {
3506                 printf("open of %s failed (%s)\n", fname, nt_errstr(status));
3507                 return False;
3508         }
3509
3510         cli1->use_oplocks = False;
3511
3512         cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
3513         cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
3514
3515         status = cli_close(cli1, fnum1);
3516         if (!NT_STATUS_IS_OK(status)) {
3517                 printf("close2 failed (%s)\n", nt_errstr(status));
3518                 return False;
3519         }
3520
3521         status = cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
3522         if (!NT_STATUS_IS_OK(status)) {
3523                 printf("unlink failed (%s)\n", nt_errstr(status));
3524                 return False;
3525         }
3526
3527         if (!torture_close_connection(cli1)) {
3528                 correct = False;
3529         }
3530
3531         printf("finished oplock test 1\n");
3532
3533         return correct;
3534 }
3535
3536 static bool run_oplock2(int dummy)
3537 {
3538         struct cli_state *cli1, *cli2;
3539         const char *fname = "\\lockt2.lck";
3540         uint16_t fnum1, fnum2;
3541         int saved_use_oplocks = use_oplocks;
3542         char buf[4];
3543         bool correct = True;
3544         volatile bool *shared_correct;
3545         size_t nread;
3546         NTSTATUS status;
3547
3548         shared_correct = (volatile bool *)shm_setup(sizeof(bool));
3549         *shared_correct = True;
3550
3551         use_level_II_oplocks = True;
3552         use_oplocks = True;
3553
3554         printf("starting oplock test 2\n");
3555
3556         if (!torture_open_connection(&cli1, 0)) {
3557                 use_level_II_oplocks = False;
3558                 use_oplocks = saved_use_oplocks;
3559                 return False;
3560         }
3561
3562         if (!torture_open_connection(&cli2, 1)) {
3563                 use_level_II_oplocks = False;
3564                 use_oplocks = saved_use_oplocks;
3565                 return False;
3566         }
3567
3568         cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
3569
3570         cli_sockopt(cli1, sockops);
3571         cli_sockopt(cli2, sockops);
3572
3573         status = cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE,
3574                           &fnum1);
3575         if (!NT_STATUS_IS_OK(status)) {
3576                 printf("open of %s failed (%s)\n", fname, nt_errstr(status));
3577                 return False;
3578         }
3579
3580         /* Don't need the globals any more. */
3581         use_level_II_oplocks = False;
3582         use_oplocks = saved_use_oplocks;
3583
3584         if (fork() == 0) {
3585                 /* Child code */
3586                 status = cli_open(cli2, fname, O_RDWR, DENY_NONE, &fnum2);
3587                 if (!NT_STATUS_IS_OK(status)) {
3588                         printf("second open of %s failed (%s)\n", fname, nt_errstr(status));
3589                         *shared_correct = False;
3590                         exit(0);
3591                 }
3592
3593                 sleep(2);
3594
3595                 status = cli_close(cli2, fnum2);
3596                 if (!NT_STATUS_IS_OK(status)) {
3597                         printf("close2 failed (%s)\n", nt_errstr(status));
3598                         *shared_correct = False;
3599                 }
3600
3601                 exit(0);
3602         }
3603
3604         sleep(2);
3605
3606         /* Ensure cli1 processes the break. Empty file should always return 0
3607          * bytes.  */
3608         status = cli_read(cli1, fnum1, buf, 0, 4, &nread);
3609         if (!NT_STATUS_IS_OK(status)) {
3610                 printf("read on fnum1 failed (%s)\n", nt_errstr(status));
3611                 correct = false;
3612         } else if (nread != 0) {
3613                 printf("read on empty fnum1 failed. recv %ld expected %d\n",
3614                       (unsigned long)nread, 0);
3615                 correct = false;
3616         }
3617
3618         /* Should now be at level II. */
3619         /* Test if sending a write locks causes a break to none. */
3620         status = cli_lock32(cli1, fnum1, 0, 4, 0, READ_LOCK);
3621         if (!NT_STATUS_IS_OK(status)) {
3622                 printf("lock failed (%s)\n", nt_errstr(status));
3623                 correct = False;
3624         }
3625
3626         cli_unlock(cli1, fnum1, 0, 4);
3627
3628         sleep(2);
3629
3630         status = cli_lock32(cli1, fnum1, 0, 4, 0, WRITE_LOCK);
3631         if (!NT_STATUS_IS_OK(status)) {
3632                 printf("lock failed (%s)\n", nt_errstr(status));
3633                 correct = False;
3634         }
3635
3636         cli_unlock(cli1, fnum1, 0, 4);
3637
3638         sleep(2);
3639
3640         cli_read(cli1, fnum1, buf, 0, 4, NULL);
3641
3642         status = cli_close(cli1, fnum1);
3643         if (!NT_STATUS_IS_OK(status)) {
3644                 printf("close1 failed (%s)\n", nt_errstr(status));
3645                 correct = False;
3646         }
3647
3648         sleep(4);
3649
3650         status = cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
3651         if (!NT_STATUS_IS_OK(status)) {
3652                 printf("unlink failed (%s)\n", nt_errstr(status));
3653                 correct = False;
3654         }
3655
3656         if (!torture_close_connection(cli1)) {
3657                 correct = False;
3658         }
3659
3660         if (!*shared_correct) {
3661                 correct = False;
3662         }
3663
3664         printf("finished oplock test 2\n");
3665
3666         return correct;
3667 }
3668
3669 struct oplock4_state {
3670         struct tevent_context *ev;
3671         struct cli_state *cli;
3672         bool *got_break;
3673         uint16_t *fnum2;
3674 };
3675
3676 static void oplock4_got_break(struct tevent_req *req);
3677 static void oplock4_got_open(struct tevent_req *req);
3678
3679 static bool run_oplock4(int dummy)
3680 {
3681         struct tevent_context *ev;
3682         struct cli_state *cli1, *cli2;
3683         struct tevent_req *oplock_req, *open_req;
3684         const char *fname = "\\lockt4.lck";
3685         const char *fname_ln = "\\lockt4_ln.lck";
3686         uint16_t fnum1, fnum2;
3687         int saved_use_oplocks = use_oplocks;
3688         NTSTATUS status;
3689         bool correct = true;
3690
3691         bool got_break;
3692
3693         struct oplock4_state *state;
3694
3695         printf("starting oplock test 4\n");
3696
3697         if (!torture_open_connection(&cli1, 0)) {
3698                 use_level_II_oplocks = false;
3699                 use_oplocks = saved_use_oplocks;
3700                 return false;
3701         }
3702
3703         if (!torture_open_connection(&cli2, 1)) {
3704                 use_level_II_oplocks = false;
3705                 use_oplocks = saved_use_oplocks;
3706                 return false;
3707         }
3708
3709         cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
3710         cli_unlink(cli1, fname_ln, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
3711
3712         cli_sockopt(cli1, sockops);
3713         cli_sockopt(cli2, sockops);
3714
3715         /* Create the file. */
3716         status = cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE,
3717                           &fnum1);
3718         if (!NT_STATUS_IS_OK(status)) {
3719                 printf("open of %s failed (%s)\n", fname, nt_errstr(status));
3720                 return false;
3721         }
3722
3723         status = cli_close(cli1, fnum1);
3724         if (!NT_STATUS_IS_OK(status)) {
3725                 printf("close1 failed (%s)\n", nt_errstr(status));
3726                 return false;
3727         }
3728
3729         /* Now create a hardlink. */
3730         status = cli_nt_hardlink(cli1, fname, fname_ln);
3731         if (!NT_STATUS_IS_OK(status)) {
3732                 printf("nt hardlink failed (%s)\n", nt_errstr(status));
3733                 return false;
3734         }
3735
3736         /* Prove that opening hardlinks cause deny modes to conflict. */
3737         status = cli_open(cli1, fname, O_RDWR, DENY_ALL, &fnum1);
3738         if (!NT_STATUS_IS_OK(status)) {
3739                 printf("open of %s failed (%s)\n", fname, nt_errstr(status));
3740                 return false;
3741         }
3742
3743         status = cli_open(cli1, fname_ln, O_RDWR, DENY_NONE, &fnum2);
3744         if (NT_STATUS_IS_OK(status)) {
3745                 printf("open of %s succeeded - should fail with sharing violation.\n",
3746                         fname_ln);
3747                 return false;
3748         }
3749
3750         if (!NT_STATUS_EQUAL(status, NT_STATUS_SHARING_VIOLATION)) {
3751                 printf("open of %s should fail with sharing violation. Got %s\n",
3752                         fname_ln, nt_errstr(status));
3753                 return false;
3754         }
3755
3756         status = cli_close(cli1, fnum1);
3757         if (!NT_STATUS_IS_OK(status)) {
3758                 printf("close1 failed (%s)\n", nt_errstr(status));
3759                 return false;
3760         }
3761
3762         cli1->use_oplocks = true;
3763         cli1->use_level_II_oplocks = true;
3764
3765         cli2->use_oplocks = true;
3766         cli2->use_level_II_oplocks = true;
3767
3768         status = cli_open(cli1, fname, O_RDWR, DENY_NONE, &fnum1);
3769         if (!NT_STATUS_IS_OK(status)) {
3770                 printf("open of %s failed (%s)\n", fname, nt_errstr(status));
3771                 return false;
3772         }
3773
3774         ev = tevent_context_init(talloc_tos());
3775         if (ev == NULL) {
3776                 printf("tevent_req_create failed\n");
3777                 return false;
3778         }
3779
3780         state = talloc(ev, struct oplock4_state);
3781         if (state == NULL) {
3782                 printf("talloc failed\n");
3783                 return false;
3784         }
3785         state->ev = ev;
3786         state->cli = cli1;
3787         state->got_break = &got_break;
3788         state->fnum2 = &fnum2;
3789
3790         oplock_req = cli_smb_oplock_break_waiter_send(
3791                 talloc_tos(), ev, cli1);
3792         if (oplock_req == NULL) {
3793                 printf("cli_smb_oplock_break_waiter_send failed\n");
3794                 return false;
3795         }
3796         tevent_req_set_callback(oplock_req, oplock4_got_break, state);
3797
3798         open_req = cli_open_send(
3799                 talloc_tos(), ev, cli2, fname_ln, O_RDWR, DENY_NONE);
3800         if (oplock_req == NULL) {
3801                 printf("cli_open_send failed\n");
3802                 return false;
3803         }
3804         tevent_req_set_callback(open_req, oplock4_got_open, state);
3805
3806         got_break = false;
3807         fnum2 = 0xffff;
3808
3809         while (!got_break || fnum2 == 0xffff) {
3810                 int ret;
3811                 ret = tevent_loop_once(ev);
3812                 if (ret == -1) {
3813                         printf("tevent_loop_once failed: %s\n",
3814                                strerror(errno));
3815                         return false;
3816                 }
3817         }
3818
3819         status = cli_close(cli2, fnum2);
3820         if (!NT_STATUS_IS_OK(status)) {
3821                 printf("close2 failed (%s)\n", nt_errstr(status));
3822                 correct = false;
3823         }
3824
3825         status = cli_close(cli1, fnum1);
3826         if (!NT_STATUS_IS_OK(status)) {
3827                 printf("close1 failed (%s)\n", nt_errstr(status));
3828                 correct = false;
3829         }
3830
3831         status = cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
3832         if (!NT_STATUS_IS_OK(status)) {
3833                 printf("unlink failed (%s)\n", nt_errstr(status));
3834                 correct = false;
3835         }
3836
3837         status = cli_unlink(cli1, fname_ln, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
3838         if (!NT_STATUS_IS_OK(status)) {
3839                 printf("unlink failed (%s)\n", nt_errstr(status));
3840                 correct = false;
3841         }
3842
3843         if (!torture_close_connection(cli1)) {
3844                 correct = false;
3845         }
3846
3847         if (!got_break) {
3848                 correct = false;
3849         }
3850
3851         printf("finished oplock test 4\n");
3852
3853         return correct;
3854 }
3855
3856 static void oplock4_got_break(struct tevent_req *req)
3857 {
3858         struct oplock4_state *state = tevent_req_callback_data(
3859                 req, struct oplock4_state);
3860         uint16_t fnum;
3861         uint8_t level;
3862         NTSTATUS status;
3863
3864         status = cli_smb_oplock_break_waiter_recv(req, &fnum, &level);
3865         TALLOC_FREE(req);
3866         if (!NT_STATUS_IS_OK(status)) {
3867                 printf("cli_smb_oplock_break_waiter_recv returned %s\n",
3868                        nt_errstr(status));
3869                 return;
3870         }
3871         *state->got_break = true;
3872
3873         req = cli_oplock_ack_send(state, state->ev, state->cli, fnum,
3874                                   NO_OPLOCK);
3875         if (req == NULL) {
3876                 printf("cli_oplock_ack_send failed\n");
3877                 return;
3878         }
3879 }
3880
3881 static void oplock4_got_open(struct tevent_req *req)
3882 {
3883         struct oplock4_state *state = tevent_req_callback_data(
3884                 req, struct oplock4_state);
3885         NTSTATUS status;
3886
3887         status = cli_open_recv(req, state->fnum2);
3888         if (!NT_STATUS_IS_OK(status)) {
3889                 printf("cli_open_recv returned %s\n", nt_errstr(status));
3890                 *state->fnum2 = 0xffff;
3891         }
3892 }
3893
3894 /*
3895   Test delete on close semantics.
3896  */
3897 static bool run_deletetest(int dummy)
3898 {
3899         struct cli_state *cli1 = NULL;
3900         struct cli_state *cli2 = NULL;
3901         const char *fname = "\\delete.file";
3902         uint16_t fnum1 = (uint16_t)-1;
3903         uint16_t fnum2 = (uint16_t)-1;
3904         bool correct = True;
3905         NTSTATUS status;
3906
3907         printf("starting delete test\n");
3908
3909         if (!torture_open_connection(&cli1, 0)) {
3910                 return False;
3911         }
3912
3913         cli_sockopt(cli1, sockops);
3914
3915         /* Test 1 - this should delete the file on close. */
3916
3917         cli_setatr(cli1, fname, 0, 0);
3918         cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
3919
3920         status = cli_ntcreate(cli1, fname, 0, GENERIC_ALL_ACCESS|DELETE_ACCESS,
3921                               FILE_ATTRIBUTE_NORMAL, 0, FILE_OVERWRITE_IF,
3922                               FILE_DELETE_ON_CLOSE, 0, &fnum1);
3923         if (!NT_STATUS_IS_OK(status)) {
3924                 printf("[1] open of %s failed (%s)\n", fname, nt_errstr(status));
3925                 correct = False;
3926                 goto fail;
3927         }
3928
3929         status = cli_close(cli1, fnum1);
3930         if (!NT_STATUS_IS_OK(status)) {
3931                 printf("[1] close failed (%s)\n", nt_errstr(status));
3932                 correct = False;
3933                 goto fail;
3934         }
3935
3936         if (NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDWR, DENY_NONE, &fnum1))) {
3937                 printf("[1] open of %s succeeded (should fail)\n", fname);
3938                 correct = False;
3939                 goto fail;
3940         }
3941
3942         printf("first delete on close test succeeded.\n");
3943
3944         /* Test 2 - this should delete the file on close. */
3945
3946         cli_setatr(cli1, fname, 0, 0);
3947         cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
3948
3949         status = cli_ntcreate(cli1, fname, 0, GENERIC_ALL_ACCESS,
3950                               FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE,
3951                               FILE_OVERWRITE_IF, 0, 0, &fnum1);
3952         if (!NT_STATUS_IS_OK(status)) {
3953                 printf("[2] open of %s failed (%s)\n", fname, nt_errstr(status));
3954                 correct = False;
3955                 goto fail;
3956         }
3957
3958         status = cli_nt_delete_on_close(cli1, fnum1, true);
3959         if (!NT_STATUS_IS_OK(status)) {
3960                 printf("[2] setting delete_on_close failed (%s)\n", nt_errstr(status));
3961                 correct = False;
3962                 goto fail;
3963         }
3964
3965         status = cli_close(cli1, fnum1);
3966         if (!NT_STATUS_IS_OK(status)) {
3967                 printf("[2] close failed (%s)\n", nt_errstr(status));
3968                 correct = False;
3969                 goto fail;
3970         }
3971
3972         if (NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDONLY, DENY_NONE, &fnum1))) {
3973                 printf("[2] open of %s succeeded should have been deleted on close !\n", fname);
3974                 status = cli_close(cli1, fnum1);
3975                 if (!NT_STATUS_IS_OK(status)) {
3976                         printf("[2] close failed (%s)\n", nt_errstr(status));
3977                         correct = False;
3978                         goto fail;
3979                 }
3980                 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
3981         } else
3982                 printf("second delete on close test succeeded.\n");
3983
3984         /* Test 3 - ... */
3985         cli_setatr(cli1, fname, 0, 0);
3986         cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
3987
3988         status = cli_ntcreate(cli1, fname, 0, GENERIC_ALL_ACCESS,
3989                               FILE_ATTRIBUTE_NORMAL,
3990                               FILE_SHARE_READ|FILE_SHARE_WRITE,
3991                               FILE_OVERWRITE_IF, 0, 0, &fnum1);
3992         if (!NT_STATUS_IS_OK(status)) {
3993                 printf("[3] open - 1 of %s failed (%s)\n", fname, nt_errstr(status));
3994                 correct = False;
3995                 goto fail;
3996         }
3997
3998         /* This should fail with a sharing violation - open for delete is only compatible
3999            with SHARE_DELETE. */
4000
4001         if (NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS, FILE_ATTRIBUTE_NORMAL,
4002                         FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OPEN, 0, 0, &fnum2))) {
4003                 printf("[3] open  - 2 of %s succeeded - should have failed.\n", fname);
4004                 correct = False;
4005                 goto fail;
4006         }
4007
4008         /* This should succeed. */
4009         status = cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS,
4010                              FILE_ATTRIBUTE_NORMAL,
4011                              FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
4012                              FILE_OPEN, 0, 0, &fnum2);
4013         if (!NT_STATUS_IS_OK(status)) {
4014                 printf("[3] open  - 2 of %s failed (%s)\n", fname, nt_errstr(status));
4015                 correct = False;
4016                 goto fail;
4017         }
4018
4019         status = cli_nt_delete_on_close(cli1, fnum1, true);
4020         if (!NT_STATUS_IS_OK(status)) {
4021                 printf("[3] setting delete_on_close failed (%s)\n", nt_errstr(status));
4022                 correct = False;
4023                 goto fail;
4024         }
4025
4026         status = cli_close(cli1, fnum1);
4027         if (!NT_STATUS_IS_OK(status)) {
4028                 printf("[3] close 1 failed (%s)\n", nt_errstr(status));
4029                 correct = False;
4030                 goto fail;
4031         }
4032
4033         status = cli_close(cli1, fnum2);
4034         if (!NT_STATUS_IS_OK(status)) {
4035                 printf("[3] close 2 failed (%s)\n", nt_errstr(status));
4036                 correct = False;
4037                 goto fail;
4038         }
4039
4040         /* This should fail - file should no longer be there. */
4041
4042         if (NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDONLY, DENY_NONE, &fnum1))) {
4043                 printf("[3] open of %s succeeded should have been deleted on close !\n", fname);
4044                 status = cli_close(cli1, fnum1);
4045                 if (!NT_STATUS_IS_OK(status)) {
4046                         printf("[3] close failed (%s)\n", nt_errstr(status));
4047                 }
4048                 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4049                 correct = False;
4050                 goto fail;
4051         } else
4052                 printf("third delete on close test succeeded.\n");
4053
4054         /* Test 4 ... */
4055         cli_setatr(cli1, fname, 0, 0);
4056         cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4057
4058         status = cli_ntcreate(cli1, fname, 0,
4059                               FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
4060                               FILE_ATTRIBUTE_NORMAL,
4061                               FILE_SHARE_READ|FILE_SHARE_WRITE,
4062                               FILE_OVERWRITE_IF, 0, 0, &fnum1);
4063         if (!NT_STATUS_IS_OK(status)) {
4064                 printf("[4] open of %s failed (%s)\n", fname, nt_errstr(status));
4065                 correct = False;
4066                 goto fail;
4067         }
4068
4069         /* This should succeed. */
4070         status = cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS,
4071                              FILE_ATTRIBUTE_NORMAL,
4072                              FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
4073                              FILE_OPEN, 0, 0, &fnum2);
4074         if (!NT_STATUS_IS_OK(status)) {
4075                 printf("[4] open  - 2 of %s failed (%s)\n", fname, nt_errstr(status));
4076                 correct = False;
4077                 goto fail;
4078         }
4079
4080         status = cli_close(cli1, fnum2);
4081         if (!NT_STATUS_IS_OK(status)) {
4082                 printf("[4] close - 1 failed (%s)\n", nt_errstr(status));
4083                 correct = False;
4084                 goto fail;
4085         }
4086
4087         status = cli_nt_delete_on_close(cli1, fnum1, true);
4088         if (!NT_STATUS_IS_OK(status)) {
4089                 printf("[4] setting delete_on_close failed (%s)\n", nt_errstr(status));
4090                 correct = False;
4091                 goto fail;
4092         }
4093
4094         /* This should fail - no more opens once delete on close set. */
4095         if (NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS,
4096                                    FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
4097                                    FILE_OPEN, 0, 0, &fnum2))) {
4098                 printf("[4] open  - 3 of %s succeeded ! Should have failed.\n", fname );
4099                 correct = False;
4100                 goto fail;
4101         } else
4102                 printf("fourth delete on close test succeeded.\n");
4103
4104         status = cli_close(cli1, fnum1);
4105         if (!NT_STATUS_IS_OK(status)) {
4106                 printf("[4] close - 2 failed (%s)\n", nt_errstr(status));
4107                 correct = False;
4108                 goto fail;
4109         }
4110
4111         /* Test 5 ... */
4112         cli_setatr(cli1, fname, 0, 0);
4113         cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4114
4115         status = cli_open(cli1, fname, O_RDWR|O_CREAT, DENY_NONE, &fnum1);
4116         if (!NT_STATUS_IS_OK(status)) {
4117                 printf("[5] open of %s failed (%s)\n", fname, nt_errstr(status));
4118                 correct = False;
4119                 goto fail;
4120         }
4121
4122         /* This should fail - only allowed on NT opens with DELETE access. */
4123
4124         if (NT_STATUS_IS_OK(cli_nt_delete_on_close(cli1, fnum1, true))) {
4125                 printf("[5] setting delete_on_close on OpenX file succeeded - should fail !\n");
4126                 correct = False;
4127                 goto fail;
4128         }
4129
4130         status = cli_close(cli1, fnum1);
4131         if (!NT_STATUS_IS_OK(status)) {
4132                 printf("[5] close - 2 failed (%s)\n", nt_errstr(status));
4133                 correct = False;
4134                 goto fail;
4135         }
4136
4137         printf("fifth delete on close test succeeded.\n");
4138
4139         /* Test 6 ... */
4140         cli_setatr(cli1, fname, 0, 0);
4141         cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4142
4143         status = cli_ntcreate(cli1, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA,
4144                              FILE_ATTRIBUTE_NORMAL,
4145                              FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
4146                              FILE_OVERWRITE_IF, 0, 0, &fnum1);
4147         if (!NT_STATUS_IS_OK(status)) {
4148                 printf("[6] open of %s failed (%s)\n", fname,
4149                        nt_errstr(status));
4150                 correct = False;
4151                 goto fail;
4152         }
4153
4154         /* This should fail - only allowed on NT opens with DELETE access. */
4155
4156         if (NT_STATUS_IS_OK(cli_nt_delete_on_close(cli1, fnum1, true))) {
4157                 printf("[6] setting delete_on_close on file with no delete access succeeded - should fail !\n");
4158                 correct = False;
4159                 goto fail;
4160         }
4161
4162         status = cli_close(cli1, fnum1);
4163         if (!NT_STATUS_IS_OK(status)) {
4164                 printf("[6] close - 2 failed (%s)\n", nt_errstr(status));
4165                 correct = False;
4166                 goto fail;
4167         }
4168
4169         printf("sixth delete on close test succeeded.\n");
4170
4171         /* Test 7 ... */
4172         cli_setatr(cli1, fname, 0, 0);
4173         cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4174
4175         status = cli_ntcreate(cli1, fname, 0,
4176                               FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
4177                               FILE_ATTRIBUTE_NORMAL, 0, FILE_OVERWRITE_IF,
4178                               0, 0, &fnum1);
4179         if (!NT_STATUS_IS_OK(status)) {
4180                 printf("[7] open of %s failed (%s)\n", fname, nt_errstr(status));
4181                 correct = False;
4182                 goto fail;
4183         }
4184
4185         if (!NT_STATUS_IS_OK(cli_nt_delete_on_close(cli1, fnum1, true))) {
4186                 printf("[7] setting delete_on_close on file failed !\n");
4187                 correct = False;
4188                 goto fail;
4189         }
4190
4191         if (!NT_STATUS_IS_OK(cli_nt_delete_on_close(cli1, fnum1, false))) {
4192                 printf("[7] unsetting delete_on_close on file failed !\n");
4193                 correct = False;
4194                 goto fail;
4195         }
4196
4197         status = cli_close(cli1, fnum1);
4198         if (!NT_STATUS_IS_OK(status)) {
4199                 printf("[7] close - 2 failed (%s)\n", nt_errstr(status));
4200                 correct = False;
4201                 goto fail;
4202         }
4203
4204         /* This next open should succeed - we reset the flag. */
4205         status = cli_open(cli1, fname, O_RDONLY, DENY_NONE, &fnum1);
4206         if (!NT_STATUS_IS_OK(status)) {
4207                 printf("[5] open of %s failed (%s)\n", fname, nt_errstr(status));
4208                 correct = False;
4209                 goto fail;
4210         }
4211
4212         status = cli_close(cli1, fnum1);
4213         if (!NT_STATUS_IS_OK(status)) {
4214                 printf("[7] close - 2 failed (%s)\n", nt_errstr(status));
4215                 correct = False;
4216                 goto fail;
4217         }
4218
4219         printf("seventh delete on close test succeeded.\n");
4220
4221         /* Test 7 ... */
4222         cli_setatr(cli1, fname, 0, 0);
4223         cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4224
4225         if (!torture_open_connection(&cli2, 1)) {
4226                 printf("[8] failed to open second connection.\n");
4227                 correct = False;
4228                 goto fail;
4229         }
4230
4231         cli_sockopt(cli1, sockops);
4232
4233         status = cli_ntcreate(cli1, fname, 0,
4234                              FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
4235                              FILE_ATTRIBUTE_NORMAL,
4236                              FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
4237                              FILE_OVERWRITE_IF, 0, 0, &fnum1);
4238         if (!NT_STATUS_IS_OK(status)) {
4239                 printf("[8] open 1 of %s failed (%s)\n", fname, nt_errstr(status));
4240                 correct = False;
4241                 goto fail;
4242         }
4243
4244         status = cli_ntcreate(cli2, fname, 0,
4245                              FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
4246                              FILE_ATTRIBUTE_NORMAL,
4247                              FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
4248                              FILE_OPEN, 0, 0, &fnum2);
4249         if (!NT_STATUS_IS_OK(status)) {
4250                 printf("[8] open 2 of %s failed (%s)\n", fname, nt_errstr(status));
4251                 correct = False;
4252                 goto fail;
4253         }
4254
4255         if (!NT_STATUS_IS_OK(cli_nt_delete_on_close(cli1, fnum1, true))) {
4256                 printf("[8] setting delete_on_close on file failed !\n");
4257                 correct = False;
4258                 goto fail;
4259         }
4260
4261         status = cli_close(cli1, fnum1);
4262         if (!NT_STATUS_IS_OK(status)) {
4263                 printf("[8] close - 1 failed (%s)\n", nt_errstr(status));
4264                 correct = False;
4265                 goto fail;
4266         }
4267
4268         status = cli_close(cli2, fnum2);
4269         if (!NT_STATUS_IS_OK(status)) {
4270                 printf("[8] close - 2 failed (%s)\n", nt_errstr(status));
4271                 correct = False;
4272                 goto fail;
4273         }
4274
4275         /* This should fail.. */
4276         status = cli_open(cli1, fname, O_RDONLY, DENY_NONE, &fnum1);
4277         if (NT_STATUS_IS_OK(status)) {
4278                 printf("[8] open of %s succeeded should have been deleted on close !\n", fname);
4279                 goto fail;
4280                 correct = False;
4281         } else
4282                 printf("eighth delete on close test succeeded.\n");
4283
4284         /* This should fail - we need to set DELETE_ACCESS. */
4285         if (NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0,FILE_READ_DATA|FILE_WRITE_DATA,
4286                                    FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE, FILE_OVERWRITE_IF, FILE_DELETE_ON_CLOSE, 0, &fnum1))) {
4287                 printf("[9] open of %s succeeded should have failed!\n", fname);
4288                 correct = False;
4289                 goto fail;
4290         }
4291
4292         printf("ninth delete on close test succeeded.\n");
4293
4294         status = cli_ntcreate(cli1, fname, 0,
4295                              FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
4296                              FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE,
4297                              FILE_OVERWRITE_IF, FILE_DELETE_ON_CLOSE,
4298                              0, &fnum1);
4299         if (!NT_STATUS_IS_OK(status)) {
4300                 printf("[10] open of %s failed (%s)\n", fname, nt_errstr(status));
4301                 correct = False;
4302                 goto fail;
4303         }
4304
4305         /* This should delete the file. */
4306         status = cli_close(cli1, fnum1);
4307         if (!NT_STATUS_IS_OK(status)) {
4308                 printf("[10] close failed (%s)\n", nt_errstr(status));
4309                 correct = False;
4310                 goto fail;
4311         }
4312
4313         /* This should fail.. */
4314         if (NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDONLY, DENY_NONE, &fnum1))) {
4315                 printf("[10] open of %s succeeded should have been deleted on close !\n", fname);
4316                 goto fail;
4317                 correct = False;
4318         } else
4319                 printf("tenth delete on close test succeeded.\n");
4320
4321         cli_setatr(cli1, fname, 0, 0);
4322         cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4323
4324         /* What error do we get when attempting to open a read-only file with
4325            delete access ? */
4326
4327         /* Create a readonly file. */
4328         status = cli_ntcreate(cli1, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA,
4329                               FILE_ATTRIBUTE_READONLY, FILE_SHARE_NONE,
4330                               FILE_OVERWRITE_IF, 0, 0, &fnum1);
4331         if (!NT_STATUS_IS_OK(status)) {
4332                 printf("[11] open of %s failed (%s)\n", fname, nt_errstr(status));
4333                 correct = False;
4334                 goto fail;
4335         }
4336
4337         status = cli_close(cli1, fnum1);
4338         if (!NT_STATUS_IS_OK(status)) {
4339                 printf("[11] close failed (%s)\n", nt_errstr(status));
4340                 correct = False;
4341                 goto fail;
4342         }
4343
4344         /* Now try open for delete access. */
4345         if (NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, FILE_READ_ATTRIBUTES|DELETE_ACCESS,
4346                                    0, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
4347                                    FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
4348                 printf("[11] open of %s succeeded should have been denied with ACCESS_DENIED!\n", fname);
4349                 cli_close(cli1, fnum1);
4350                 goto fail;
4351                 correct = False;
4352         } else {
4353                 NTSTATUS nterr = cli_nt_error(cli1);
4354                 if (!NT_STATUS_EQUAL(nterr,NT_STATUS_ACCESS_DENIED)) {
4355                         printf("[11] open of %s should have been denied with ACCESS_DENIED! Got error %s\n", fname, nt_errstr(nterr));
4356                         goto fail;
4357                         correct = False;
4358                 } else {
4359                         printf("eleventh delete on close test succeeded.\n");
4360                 }
4361         }
4362
4363         printf("finished delete test\n");
4364
4365   fail:
4366         /* FIXME: This will crash if we aborted before cli2 got
4367          * intialized, because these functions don't handle
4368          * uninitialized connections. */
4369
4370         if (fnum1 != (uint16_t)-1) cli_close(cli1, fnum1);
4371         if (fnum2 != (uint16_t)-1) cli_close(cli1, fnum2);
4372         cli_setatr(cli1, fname, 0, 0);
4373         cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4374
4375         if (cli1 && !torture_close_connection(cli1)) {
4376                 correct = False;
4377         }
4378         if (cli2 && !torture_close_connection(cli2)) {
4379                 correct = False;
4380         }
4381         return correct;
4382 }
4383
4384 static bool run_deletetest_ln(int dummy)
4385 {
4386         struct cli_state *cli;
4387         const char *fname = "\\delete1";
4388         const char *fname_ln = "\\delete1_ln";
4389         uint16_t fnum;
4390         uint16_t fnum1;
4391         NTSTATUS status;
4392         bool correct = true;
4393         time_t t;
4394
4395         printf("starting deletetest-ln\n");
4396
4397         if (!torture_open_connection(&cli, 0)) {
4398                 return false;
4399         }
4400
4401         cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4402         cli_unlink(cli, fname_ln, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4403
4404         cli_sockopt(cli, sockops);
4405
4406         /* Create the file. */
4407         status = cli_open(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum);
4408         if (!NT_STATUS_IS_OK(status)) {
4409                 printf("open of %s failed (%s)\n", fname, nt_errstr(status));
4410                 return false;
4411         }
4412
4413         status = cli_close(cli, fnum);
4414         if (!NT_STATUS_IS_OK(status)) {
4415                 printf("close1 failed (%s)\n", nt_errstr(status));
4416                 return false;
4417         }
4418
4419         /* Now create a hardlink. */
4420         status = cli_nt_hardlink(cli, fname, fname_ln);
4421         if (!NT_STATUS_IS_OK(status)) {
4422                 printf("nt hardlink failed (%s)\n", nt_errstr(status));
4423                 return false;
4424         }
4425
4426         /* Open the original file. */
4427         status = cli_ntcreate(cli, fname, 0, FILE_READ_DATA,
4428                         FILE_ATTRIBUTE_NORMAL,
4429                         FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
4430                         FILE_OPEN_IF, 0, 0, &fnum);
4431         if (!NT_STATUS_IS_OK(status)) {
4432                 printf("ntcreate of %s failed (%s)\n", fname, nt_errstr(status));
4433                 return false;
4434         }
4435
4436         /* Unlink the hard link path. */
4437         status = cli_ntcreate(cli, fname_ln, 0, DELETE_ACCESS,
4438                         FILE_ATTRIBUTE_NORMAL,
4439                         FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
4440                         FILE_OPEN_IF, 0, 0, &fnum1);
4441         if (!NT_STATUS_IS_OK(status)) {
4442                 printf("ntcreate of %s failed (%s)\n", fname_ln, nt_errstr(status));
4443                 return false;
4444         }
4445         status = cli_nt_delete_on_close(cli, fnum1, true);
4446         if (!NT_STATUS_IS_OK(status)) {
4447                 d_printf("(%s) failed to set delete_on_close %s: %s\n",
4448                         __location__, fname_ln, nt_errstr(status));
4449                 return false;
4450         }
4451
4452         status = cli_close(cli, fnum1);
4453         if (!NT_STATUS_IS_OK(status)) {
4454                 printf("close %s failed (%s)\n",
4455                         fname_ln, nt_errstr(status));
4456                 return false;
4457         }
4458
4459         status = cli_close(cli, fnum);
4460         if (!NT_STATUS_IS_OK(status)) {
4461                 printf("close %s failed (%s)\n",
4462                         fname, nt_errstr(status));
4463                 return false;
4464         }
4465
4466         /* Ensure the original file is still there. */
4467         status = cli_getatr(cli, fname, NULL, NULL, &t);
4468         if (!NT_STATUS_IS_OK(status)) {
4469                 printf("%s getatr on file %s failed (%s)\n",
4470                         __location__,
4471                         fname,
4472                         nt_errstr(status));
4473                 correct = False;
4474         }
4475
4476         /* Ensure the link path is gone. */
4477         status = cli_getatr(cli, fname_ln, NULL, NULL, &t);
4478         if (!NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
4479                 printf("%s, getatr for file %s returned wrong error code %s "
4480                         "- should have been deleted\n",
4481                         __location__,
4482                         fname_ln, nt_errstr(status));
4483                 correct = False;
4484         }
4485
4486         cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4487         cli_unlink(cli, fname_ln, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4488
4489         if (!torture_close_connection(cli)) {
4490                 correct = false;
4491         }
4492
4493         printf("finished deletetest-ln\n");
4494
4495         return correct;
4496 }
4497
4498 /*
4499   print out server properties
4500  */
4501 static bool run_properties(int dummy)
4502 {
4503         struct cli_state *cli;
4504         bool correct = True;
4505
4506         printf("starting properties test\n");
4507
4508         ZERO_STRUCT(cli);
4509
4510         if (!torture_open_connection(&cli, 0)) {
4511                 return False;
4512         }
4513
4514         cli_sockopt(cli, sockops);
4515
4516         d_printf("Capabilities 0x%08x\n", cli_state_capabilities(cli));
4517
4518         if (!torture_close_connection(cli)) {
4519                 correct = False;
4520         }
4521
4522         return correct;
4523 }
4524
4525
4526
4527 /* FIRST_DESIRED_ACCESS   0xf019f */
4528 #define FIRST_DESIRED_ACCESS   FILE_READ_DATA|FILE_WRITE_DATA|FILE_APPEND_DATA|\
4529                                FILE_READ_EA|                           /* 0xf */ \
4530                                FILE_WRITE_EA|FILE_READ_ATTRIBUTES|     /* 0x90 */ \
4531                                FILE_WRITE_ATTRIBUTES|                  /* 0x100 */ \
4532                                DELETE_ACCESS|READ_CONTROL_ACCESS|\
4533                                WRITE_DAC_ACCESS|WRITE_OWNER_ACCESS     /* 0xf0000 */
4534 /* SECOND_DESIRED_ACCESS  0xe0080 */
4535 #define SECOND_DESIRED_ACCESS  FILE_READ_ATTRIBUTES|                   /* 0x80 */ \
4536                                READ_CONTROL_ACCESS|WRITE_DAC_ACCESS|\
4537                                WRITE_OWNER_ACCESS                      /* 0xe0000 */
4538
4539 #if 0
4540 #define THIRD_DESIRED_ACCESS   FILE_READ_ATTRIBUTES|                   /* 0x80 */ \
4541                                READ_CONTROL_ACCESS|WRITE_DAC_ACCESS|\
4542                                FILE_READ_DATA|\
4543                                WRITE_OWNER_ACCESS                      /* */
4544 #endif
4545
4546 /*
4547   Test ntcreate calls made by xcopy
4548  */
4549 static bool run_xcopy(int dummy)
4550 {
4551         static struct cli_state *cli1;
4552         const char *fname = "\\test.txt";
4553         bool correct = True;
4554         uint16_t fnum1, fnum2;
4555         NTSTATUS status;
4556
4557         printf("starting xcopy test\n");
4558
4559         if (!torture_open_connection(&cli1, 0)) {
4560                 return False;
4561         }
4562
4563         status = cli_ntcreate(cli1, fname, 0, FIRST_DESIRED_ACCESS,
4564                               FILE_ATTRIBUTE_ARCHIVE, FILE_SHARE_NONE,
4565                               FILE_OVERWRITE_IF, 0x4044, 0, &fnum1);
4566         if (!NT_STATUS_IS_OK(status)) {
4567                 printf("First open failed - %s\n", nt_errstr(status));
4568                 return False;
4569         }
4570
4571         status = cli_ntcreate(cli1, fname, 0, SECOND_DESIRED_ACCESS, 0,
4572                              FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
4573                              FILE_OPEN, 0x200000, 0, &fnum2);
4574         if (!NT_STATUS_IS_OK(status)) {
4575                 printf("second open failed - %s\n", nt_errstr(status));
4576                 return False;
4577         }
4578
4579         if (!torture_close_connection(cli1)) {
4580                 correct = False;
4581         }
4582
4583         return correct;
4584 }
4585
4586 /*
4587   Test rename on files open with share delete and no share delete.
4588  */
4589 static bool run_rename(int dummy)
4590 {
4591         static struct cli_state *cli1;
4592         const char *fname = "\\test.txt";
4593         const char *fname1 = "\\test1.txt";
4594         bool correct = True;
4595         uint16_t fnum1;
4596         uint16_t attr;
4597         NTSTATUS status;
4598
4599         printf("starting rename test\n");
4600
4601         if (!torture_open_connection(&cli1, 0)) {
4602                 return False;
4603         }
4604
4605         cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4606         cli_unlink(cli1, fname1, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4607
4608         status = cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS,
4609                               FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ,
4610                               FILE_OVERWRITE_IF, 0, 0, &fnum1);
4611         if (!NT_STATUS_IS_OK(status)) {
4612                 printf("First open failed - %s\n", nt_errstr(status));
4613                 return False;
4614         }
4615
4616         status = cli_rename(cli1, fname, fname1);
4617         if (!NT_STATUS_IS_OK(status)) {
4618                 printf("First rename failed (SHARE_READ) (this is correct) - %s\n", nt_errstr(status));
4619         } else {
4620                 printf("First rename succeeded (SHARE_READ) - this should have failed !\n");
4621                 correct = False;
4622         }
4623
4624         status = cli_close(cli1, fnum1);
4625         if (!NT_STATUS_IS_OK(status)) {
4626                 printf("close - 1 failed (%s)\n", nt_errstr(status));
4627                 return False;
4628         }
4629
4630         cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4631         cli_unlink(cli1, fname1, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4632         status = cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS, FILE_ATTRIBUTE_NORMAL,
4633 #if 0
4634                               FILE_SHARE_DELETE|FILE_SHARE_NONE,
4635 #else
4636                               FILE_SHARE_DELETE|FILE_SHARE_READ,
4637 #endif
4638                               FILE_OVERWRITE_IF, 0, 0, &fnum1);
4639         if (!NT_STATUS_IS_OK(status)) {
4640                 printf("Second open failed - %s\n", nt_errstr(status));
4641                 return False;
4642         }
4643
4644         status = cli_rename(cli1, fname, fname1);
4645         if (!NT_STATUS_IS_OK(status)) {
4646                 printf("Second rename failed (SHARE_DELETE | SHARE_READ) - this should have succeeded - %s\n", nt_errstr(status));
4647                 correct = False;
4648         } else {
4649                 printf("Second rename succeeded (SHARE_DELETE | SHARE_READ)\n");
4650         }
4651
4652         status = cli_close(cli1, fnum1);
4653         if (!NT_STATUS_IS_OK(status)) {
4654                 printf("close - 2 failed (%s)\n", nt_errstr(status));
4655                 return False;
4656         }
4657
4658         cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4659         cli_unlink(cli1, fname1, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4660
4661         status = cli_ntcreate(cli1, fname, 0, READ_CONTROL_ACCESS,
4662                               FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE,
4663                               FILE_OVERWRITE_IF, 0, 0, &fnum1);
4664         if (!NT_STATUS_IS_OK(status)) {
4665                 printf("Third open failed - %s\n", nt_errstr(status));
4666                 return False;
4667         }
4668
4669
4670 #if 0
4671   {
4672         uint16_t fnum2;
4673
4674         if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, DELETE_ACCESS, FILE_ATTRIBUTE_NORMAL,
4675                                    FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0, &fnum2))) {
4676                 printf("Fourth open failed - %s\n", cli_errstr(cli1));
4677                 return False;
4678         }
4679         if (!NT_STATUS_IS_OK(cli_nt_delete_on_close(cli1, fnum2, true))) {
4680                 printf("[8] setting delete_on_close on file failed !\n");
4681                 return False;
4682         }
4683
4684         if (!NT_STATUS_IS_OK(cli_close(cli1, fnum2))) {
4685                 printf("close - 4 failed (%s)\n", cli_errstr(cli1));
4686                 return False;
4687         }
4688   }
4689 #endif
4690
4691         status = cli_rename(cli1, fname, fname1);
4692         if (!NT_STATUS_IS_OK(status)) {
4693                 printf("Third rename failed (SHARE_NONE) - this should have succeeded - %s\n", nt_errstr(status));
4694                 correct = False;
4695         } else {
4696                 printf("Third rename succeeded (SHARE_NONE)\n");
4697         }
4698
4699         status = cli_close(cli1, fnum1);
4700         if (!NT_STATUS_IS_OK(status)) {
4701                 printf("close - 3 failed (%s)\n", nt_errstr(status));
4702                 return False;
4703         }
4704
4705         cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4706         cli_unlink(cli1, fname1, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4707
4708         /*----*/
4709
4710         status = cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS,
4711                               FILE_ATTRIBUTE_NORMAL,
4712                               FILE_SHARE_READ | FILE_SHARE_WRITE,
4713                               FILE_OVERWRITE_IF, 0, 0, &fnum1);
4714         if (!NT_STATUS_IS_OK(status)) {
4715                 printf("Fourth open failed - %s\n", nt_errstr(status));
4716                 return False;
4717         }
4718
4719         status = cli_rename(cli1, fname, fname1);
4720         if (!NT_STATUS_IS_OK(status)) {
4721                 printf("Fourth rename failed (SHARE_READ | SHARE_WRITE) (this is correct) - %s\n", nt_errstr(status));
4722         } else {
4723                 printf("Fourth rename succeeded (SHARE_READ | SHARE_WRITE) - this should have failed !\n");
4724                 correct = False;
4725         }
4726
4727         status = cli_close(cli1, fnum1);
4728         if (!NT_STATUS_IS_OK(status)) {
4729                 printf("close - 4 failed (%s)\n", nt_errstr(status));
4730                 return False;
4731         }
4732
4733         cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4734         cli_unlink(cli1, fname1, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4735
4736         /*--*/
4737
4738         status = cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS,
4739                          FILE_ATTRIBUTE_NORMAL,
4740                          FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
4741                          FILE_OVERWRITE_IF, 0, 0, &fnum1);
4742         if (!NT_STATUS_IS_OK(status)) {
4743                 printf("Fifth open failed - %s\n", nt_errstr(status));
4744                 return False;
4745         }
4746
4747         status = cli_rename(cli1, fname, fname1);
4748         if (!NT_STATUS_IS_OK(status)) {
4749                 printf("Fifth rename failed (SHARE_READ | SHARE_WRITE | SHARE_DELETE) - this should have succeeded - %s ! \n", nt_errstr(status));
4750                 correct = False;
4751         } else {
4752                 printf("Fifth rename succeeded (SHARE_READ | SHARE_WRITE | SHARE_DELETE) (this is correct) - %s\n", nt_errstr(status));
4753         }
4754
4755         /*
4756          * Now check if the first name still exists ...
4757          */
4758
4759         /* if (!NT_STATUS_OP(cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS, FILE_ATTRIBUTE_NORMAL,
4760                                    FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, FILE_OVERWRITE_IF, 0, 0, &fnum2))) {
4761           printf("Opening original file after rename of open file fails: %s\n",
4762               cli_errstr(cli1));
4763         }
4764         else {
4765           printf("Opening original file after rename of open file works ...\n");
4766           (void)cli_close(cli1, fnum2);
4767           } */
4768
4769         /*--*/
4770         status = cli_close(cli1, fnum1);
4771         if (!NT_STATUS_IS_OK(status)) {
4772                 printf("close - 5 failed (%s)\n", nt_errstr(status));
4773                 return False;
4774         }
4775
4776         /* Check that the renamed file has FILE_ATTRIBUTE_ARCHIVE. */
4777         status = cli_getatr(cli1, fname1, &attr, NULL, NULL);
4778         if (!NT_STATUS_IS_OK(status)) {
4779                 printf("getatr on file %s failed - %s ! \n",
4780                         fname1, nt_errstr(status));
4781                 correct = False;
4782         } else {
4783                 if (attr != FILE_ATTRIBUTE_ARCHIVE) {
4784                         printf("Renamed file %s has wrong attr 0x%x "
4785                                 "(should be 0x%x)\n",
4786                                 fname1,
4787                                 attr,
4788                                 (unsigned int)FILE_ATTRIBUTE_ARCHIVE);
4789                         correct = False;
4790                 } else {
4791                         printf("Renamed file %s has archive bit set\n", fname1);
4792                 }
4793         }
4794
4795         cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4796         cli_unlink(cli1, fname1, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4797
4798         if (!torture_close_connection(cli1)) {
4799                 correct = False;
4800         }
4801
4802         return correct;
4803 }
4804
4805 static bool run_pipe_number(int dummy)
4806 {
4807         struct cli_state *cli1;
4808         const char *pipe_name = "\\SPOOLSS";
4809         uint16_t fnum;
4810         int num_pipes = 0;
4811         NTSTATUS status;
4812
4813         printf("starting pipenumber test\n");
4814         if (!torture_open_connection(&cli1, 0)) {
4815                 return False;
4816         }
4817
4818         cli_sockopt(cli1, sockops);
4819         while(1) {
4820                 status = cli_ntcreate(cli1, pipe_name, 0, FILE_READ_DATA,
4821                                       FILE_ATTRIBUTE_NORMAL,
4822                                       FILE_SHARE_READ|FILE_SHARE_WRITE,
4823                                       FILE_OPEN_IF, 0, 0, &fnum);
4824                 if (!NT_STATUS_IS_OK(status)) {
4825                         printf("Open of pipe %s failed with error (%s)\n", pipe_name, nt_errstr(status));
4826                         break;
4827                 }
4828                 num_pipes++;
4829                 printf("\r%6d", num_pipes);
4830         }
4831
4832         printf("pipe_number test - we can open %d %s pipes.\n", num_pipes, pipe_name );
4833         torture_close_connection(cli1);
4834         return True;
4835 }
4836
4837 /*
4838   Test open mode returns on read-only files.
4839  */
4840 static bool run_opentest(int dummy)
4841 {
4842         static struct cli_state *cli1;
4843         static struct cli_state *cli2;
4844         const char *fname = "\\readonly.file";
4845         uint16_t fnum1, fnum2;
4846         char buf[20];
4847         SMB_OFF_T fsize;
4848         bool correct = True;
4849         char *tmp_path;
4850         NTSTATUS status;
4851
4852         printf("starting open test\n");
4853
4854         if (!torture_open_connection(&cli1, 0)) {
4855                 return False;
4856         }
4857
4858         cli_setatr(cli1, fname, 0, 0);
4859         cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4860
4861         cli_sockopt(cli1, sockops);
4862
4863         status = cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1);
4864         if (!NT_STATUS_IS_OK(status)) {
4865                 printf("open of %s failed (%s)\n", fname, nt_errstr(status));
4866                 return False;
4867         }
4868
4869         status = cli_close(cli1, fnum1);
4870         if (!NT_STATUS_IS_OK(status)) {
4871                 printf("close2 failed (%s)\n", nt_errstr(status));
4872                 return False;
4873         }
4874
4875         status = cli_setatr(cli1, fname, FILE_ATTRIBUTE_READONLY, 0);
4876         if (!NT_STATUS_IS_OK(status)) {
4877                 printf("cli_setatr failed (%s)\n", nt_errstr(status));
4878                 return False;
4879         }
4880
4881         status = cli_open(cli1, fname, O_RDONLY, DENY_WRITE, &fnum1);
4882         if (!NT_STATUS_IS_OK(status)) {
4883                 printf("open of %s failed (%s)\n", fname, nt_errstr(status));
4884                 return False;
4885         }
4886
4887         /* This will fail - but the error should be ERRnoaccess, not ERRbadshare. */
4888         status = cli_open(cli1, fname, O_RDWR, DENY_ALL, &fnum2);
4889
4890         if (check_error(__LINE__, status, ERRDOS, ERRnoaccess,
4891                         NT_STATUS_ACCESS_DENIED)) {
4892                 printf("correct error code ERRDOS/ERRnoaccess returned\n");
4893         }
4894
4895         printf("finished open test 1\n");
4896
4897         cli_close(cli1, fnum1);
4898
4899         /* Now try not readonly and ensure ERRbadshare is returned. */
4900
4901         cli_setatr(cli1, fname, 0, 0);
4902
4903         status = cli_open(cli1, fname, O_RDONLY, DENY_WRITE, &fnum1);
4904         if (!NT_STATUS_IS_OK(status)) {
4905                 printf("open of %s failed (%s)\n", fname, nt_errstr(status));
4906                 return False;
4907         }
4908
4909         /* This will fail - but the error should be ERRshare. */
4910         status = cli_open(cli1, fname, O_RDWR, DENY_ALL, &fnum2);
4911
4912         if (check_error(__LINE__, status, ERRDOS, ERRbadshare,
4913                         NT_STATUS_SHARING_VIOLATION)) {
4914                 printf("correct error code ERRDOS/ERRbadshare returned\n");
4915         }
4916
4917         status = cli_close(cli1, fnum1);
4918         if (!NT_STATUS_IS_OK(status)) {
4919                 printf("close2 failed (%s)\n", nt_errstr(status));
4920                 return False;
4921         }
4922
4923         cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4924
4925         printf("finished open test 2\n");
4926
4927         /* Test truncate open disposition on file opened for read. */
4928         status = cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1);
4929         if (!NT_STATUS_IS_OK(status)) {
4930                 printf("(3) open (1) of %s failed (%s)\n", fname, nt_errstr(status));
4931                 return False;
4932         }
4933
4934         /* write 20 bytes. */
4935
4936         memset(buf, '\0', 20);
4937
4938         status = cli_writeall(cli1, fnum1, 0, (uint8_t *)buf, 0, 20, NULL);
4939         if (!NT_STATUS_IS_OK(status)) {
4940                 printf("write failed (%s)\n", nt_errstr(status));
4941                 correct = False;
4942         }
4943
4944         status = cli_close(cli1, fnum1);
4945         if (!NT_STATUS_IS_OK(status)) {
4946                 printf("(3) close1 failed (%s)\n", nt_errstr(status));
4947                 return False;
4948         }
4949
4950         /* Ensure size == 20. */
4951         status = cli_getatr(cli1, fname, NULL, &fsize, NULL);
4952         if (!NT_STATUS_IS_OK(status)) {
4953                 printf("(3) getatr failed (%s)\n", nt_errstr(status));
4954                 return False;
4955         }
4956
4957         if (fsize != 20) {
4958                 printf("(3) file size != 20\n");
4959                 return False;
4960         }
4961
4962         /* Now test if we can truncate a file opened for readonly. */
4963         status = cli_open(cli1, fname, O_RDONLY|O_TRUNC, DENY_NONE, &fnum1);
4964         if (!NT_STATUS_IS_OK(status)) {
4965                 printf("(3) open (2) of %s failed (%s)\n", fname, nt_errstr(status));
4966                 return False;
4967         }
4968
4969         status = cli_close(cli1, fnum1);
4970         if (!NT_STATUS_IS_OK(status)) {
4971                 printf("close2 failed (%s)\n", nt_errstr(status));
4972                 return False;
4973         }
4974
4975         /* Ensure size == 0. */
4976         status = cli_getatr(cli1, fname, NULL, &fsize, NULL);
4977         if (!NT_STATUS_IS_OK(status)) {
4978                 printf("(3) getatr failed (%s)\n", nt_errstr(status));
4979                 return False;
4980         }
4981
4982         if (fsize != 0) {
4983                 printf("(3) file size != 0\n");
4984                 return False;
4985         }
4986         printf("finished open test 3\n");
4987
4988         cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4989
4990         printf("Do ctemp tests\n");
4991         status = cli_ctemp(cli1, talloc_tos(), "\\", &fnum1, &tmp_path);
4992         if (!NT_STATUS_IS_OK(status)) {
4993                 printf("ctemp failed (%s)\n", nt_errstr(status));
4994                 return False;
4995         }
4996
4997         printf("ctemp gave path %s\n", tmp_path);
4998         status = cli_close(cli1, fnum1);
4999         if (!NT_STATUS_IS_OK(status)) {
5000                 printf("close of temp failed (%s)\n", nt_errstr(status));
5001         }
5002
5003         status = cli_unlink(cli1, tmp_path, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
5004         if (!NT_STATUS_IS_OK(status)) {
5005                 printf("unlink of temp failed (%s)\n", nt_errstr(status));
5006         }
5007
5008         /* Test the non-io opens... */
5009
5010         if (!torture_open_connection(&cli2, 1)) {
5011                 return False;
5012         }
5013
5014         cli_setatr(cli2, fname, 0, 0);
5015         cli_unlink(cli2, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
5016
5017         cli_sockopt(cli2, sockops);
5018
5019         printf("TEST #1 testing 2 non-io opens (no delete)\n");
5020         status = cli_ntcreate(cli1, fname, 0, FILE_READ_ATTRIBUTES,
5021                               FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE,
5022                               FILE_OVERWRITE_IF, 0, 0, &fnum1);
5023         if (!NT_STATUS_IS_OK(status)) {
5024                 printf("TEST #1 open 1 of %s failed (%s)\n", fname, nt_errstr(status));
5025                 return False;
5026         }
5027
5028         status = cli_ntcreate(cli2, fname, 0, FILE_READ_ATTRIBUTES,
5029                               FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE,
5030                               FILE_OPEN_IF, 0, 0, &fnum2);
5031         if (!NT_STATUS_IS_OK(status)) {
5032                 printf("TEST #1 open 2 of %s failed (%s)\n", fname, nt_errstr(status));
5033                 return False;
5034         }
5035
5036         status = cli_close(cli1, fnum1);
5037         if (!NT_STATUS_IS_OK(status)) {
5038                 printf("TEST #1 close 1 of %s failed (%s)\n", fname, nt_errstr(status));
5039                 return False;
5040         }
5041
5042         status = cli_close(cli2, fnum2);
5043         if (!NT_STATUS_IS_OK(status)) {
5044                 printf("TEST #1 close 2 of %s failed (%s)\n", fname, nt_errstr(status));
5045                 return False;
5046         }
5047
5048         printf("non-io open test #1 passed.\n");
5049
5050         cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
5051
5052         printf("TEST #2 testing 2 non-io opens (first with delete)\n");
5053
5054         status = cli_ntcreate(cli1, fname, 0,
5055                               DELETE_ACCESS|FILE_READ_ATTRIBUTES,
5056                               FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE,
5057                               FILE_OVERWRITE_IF, 0, 0, &fnum1);
5058         if (!NT_STATUS_IS_OK(status)) {
5059                 printf("TEST #2 open 1 of %s failed (%s)\n", fname, nt_errstr(status));
5060                 return False;
5061         }
5062
5063         status = cli_ntcreate(cli2, fname, 0, FILE_READ_ATTRIBUTES,
5064                               FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE,
5065                               FILE_OPEN_IF, 0, 0, &fnum2);
5066         if (!NT_STATUS_IS_OK(status)) {
5067                 printf("TEST #2 open 2 of %s failed (%s)\n", fname, nt_errstr(status));
5068                 return False;
5069         }
5070
5071         status = cli_close(cli1, fnum1);
5072         if (!NT_STATUS_IS_OK(status)) {
5073                 printf("TEST #2 close 1 of %s failed (%s)\n", fname, nt_errstr(status));
5074                 return False;
5075         }
5076
5077         status = cli_close(cli2, fnum2);
5078         if (!NT_STATUS_IS_OK(status)) {
5079                 printf("TEST #2 close 2 of %s failed (%s)\n", fname, nt_errstr(status));
5080                 return False;
5081         }
5082
5083         printf("non-io open test #2 passed.\n");
5084
5085         cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
5086
5087         printf("TEST #3 testing 2 non-io opens (second with delete)\n");
5088
5089         status = cli_ntcreate(cli1, fname, 0, FILE_READ_ATTRIBUTES,
5090                               FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE,
5091                               FILE_OVERWRITE_IF, 0, 0, &fnum1);
5092         if (!NT_STATUS_IS_OK(status)) {
5093                 printf("TEST #3 open 1 of %s failed (%s)\n", fname, nt_errstr(status));
5094                 return False;
5095         }
5096
5097         status = cli_ntcreate(cli2, fname, 0,
5098                               DELETE_ACCESS|FILE_READ_ATTRIBUTES,
5099                               FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE,
5100                               FILE_OPEN_IF, 0, 0, &fnum2);
5101         if (!NT_STATUS_IS_OK(status)) {
5102                 printf("TEST #3 open 2 of %s failed (%s)\n", fname, nt_errstr(status));
5103                 return False;
5104         }
5105
5106         status = cli_close(cli1, fnum1);
5107         if (!NT_STATUS_IS_OK(status)) {
5108                 printf("TEST #3 close 1 of %s failed (%s)\n", fname, nt_errstr(status));
5109                 return False;
5110         }
5111
5112         status = cli_close(cli2, fnum2);
5113         if (!NT_STATUS_IS_OK(status)) {
5114                 printf("TEST #3 close 2 of %s failed (%s)\n", fname, nt_errstr(status));
5115                 return False;
5116         }
5117
5118         printf("non-io open test #3 passed.\n");
5119
5120         cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
5121
5122         printf("TEST #4 testing 2 non-io opens (both with delete)\n");
5123
5124         status = cli_ntcreate(cli1, fname, 0,
5125                                DELETE_ACCESS|FILE_READ_ATTRIBUTES,
5126                                FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE,
5127                                FILE_OVERWRITE_IF, 0, 0, &fnum1);
5128         if (!NT_STATUS_IS_OK(status)) {
5129                 printf("TEST #4 open 1 of %s failed (%s)\n", fname, nt_errstr(status));
5130                 return False;
5131         }
5132
5133         status = cli_ntcreate(cli2, fname, 0,
5134                               DELETE_ACCESS|FILE_READ_ATTRIBUTES,
5135                               FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE,
5136                               FILE_OPEN_IF, 0, 0, &fnum2);
5137         if (NT_STATUS_IS_OK(status)) {
5138                 printf("TEST #4 open 2 of %s SUCCEEDED - should have failed (%s)\n", fname, nt_errstr(status));
5139                 return False;
5140         }
5141
5142         printf("TEST #4 open 2 of %s gave %s (correct error should be %s)\n", fname, nt_errstr(status), "sharing violation");
5143
5144         status = cli_close(cli1, fnum1);
5145         if (!NT_STATUS_IS_OK(status)) {
5146                 printf("TEST #4 close 1 of %s failed (%s)\n", fname, nt_errstr(status));
5147                 return False;
5148         }
5149
5150         printf("non-io open test #4 passed.\n");
5151
5152         cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
5153
5154         printf("TEST #5 testing 2 non-io opens (both with delete - both with file share delete)\n");
5155
5156         status = cli_ntcreate(cli1, fname, 0,
5157                               DELETE_ACCESS|FILE_READ_ATTRIBUTES,
5158                               FILE_ATTRIBUTE_NORMAL, FILE_SHARE_DELETE,
5159                               FILE_OVERWRITE_IF, 0, 0, &fnum1);
5160         if (!NT_STATUS_IS_OK(status)) {
5161                 printf("TEST #5 open 1 of %s failed (%s)\n", fname, nt_errstr(status));
5162                 return False;
5163         }
5164
5165         status = cli_ntcreate(cli2, fname, 0,
5166                               DELETE_ACCESS|FILE_READ_ATTRIBUTES,
5167                               FILE_ATTRIBUTE_NORMAL, FILE_SHARE_DELETE,
5168                               FILE_OPEN_IF, 0, 0, &fnum2);
5169         if (!NT_STATUS_IS_OK(status)) {
5170                 printf("TEST #5 open 2 of %s failed (%s)\n", fname, nt_errstr(status));
5171                 return False;
5172         }
5173
5174         status = cli_close(cli1, fnum1);
5175         if (!NT_STATUS_IS_OK(status)) {
5176                 printf("TEST #5 close 1 of %s failed (%s)\n", fname, nt_errstr(status));
5177                 return False;
5178         }
5179
5180         status = cli_close(cli2, fnum2);
5181         if (!NT_STATUS_IS_OK(status)) {
5182                 printf("TEST #5 close 2 of %s failed (%s)\n", fname, nt_errstr(status));
5183                 return False;
5184         }
5185
5186         printf("non-io open test #5 passed.\n");
5187
5188         printf("TEST #6 testing 1 non-io open, one io open\n");
5189
5190         cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
5191
5192         status = cli_ntcreate(cli1, fname, 0, FILE_READ_DATA,
5193                               FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE,
5194                               FILE_OVERWRITE_IF, 0, 0, &fnum1);
5195         if (!NT_STATUS_IS_OK(status)) {
5196                 printf("TEST #6 open 1 of %s failed (%s)\n", fname, nt_errstr(status));
5197                 return False;
5198         }
5199
5200         status = cli_ntcreate(cli2, fname, 0, FILE_READ_ATTRIBUTES,
5201                               FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ,
5202                               FILE_OPEN_IF, 0, 0, &fnum2);
5203         if (!NT_STATUS_IS_OK(status)) {
5204                 printf("TEST #6 open 2 of %s failed (%s)\n", fname, nt_errstr(status));
5205                 return False;
5206         }
5207
5208         status = cli_close(cli1, fnum1);
5209         if (!NT_STATUS_IS_OK(status)) {
5210                 printf("TEST #6 close 1 of %s failed (%s)\n", fname, nt_errstr(status));
5211                 return False;
5212         }
5213
5214         status = cli_close(cli2, fnum2);
5215         if (!NT_STATUS_IS_OK(status)) {
5216                 printf("TEST #6 close 2 of %s failed (%s)\n", fname, nt_errstr(status));
5217                 return False;
5218         }
5219
5220         printf("non-io open test #6 passed.\n");
5221
5222         printf("TEST #7 testing 1 non-io open, one io open with delete\n");
5223
5224         cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
5225
5226         status = cli_ntcreate(cli1, fname, 0, FILE_READ_DATA,
5227                               FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE,
5228                               FILE_OVERWRITE_IF, 0, 0, &fnum1);
5229         if (!NT_STATUS_IS_OK(status)) {
5230                 printf("TEST #7 open 1 of %s failed (%s)\n", fname, nt_errstr(status));
5231                 return False;
5232         }
5233
5234         status = cli_ntcreate(cli2, fname, 0,
5235                               DELETE_ACCESS|FILE_READ_ATTRIBUTES,
5236                               FILE_ATTRIBUTE_NORMAL,
5237                               FILE_SHARE_READ|FILE_SHARE_DELETE,
5238                               FILE_OPEN_IF, 0, 0, &fnum2);
5239         if (NT_STATUS_IS_OK(status)) {
5240                 printf("TEST #7 open 2 of %s SUCCEEDED - should have failed (%s)\n", fname, nt_errstr(status));
5241                 return False;
5242         }
5243
5244         printf("TEST #7 open 2 of %s gave %s (correct error should be %s)\n", fname, nt_errstr(status), "sharing violation");
5245
5246         status = cli_close(cli1, fnum1);
5247         if (!NT_STATUS_IS_OK(status)) {
5248                 printf("TEST #7 close 1 of %s failed (%s)\n", fname, nt_errstr(status));
5249                 return False;
5250         }
5251
5252         printf("non-io open test #7 passed.\n");
5253
5254         cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
5255
5256         printf("TEST #8 testing open without WRITE_ATTRIBUTES, updating close write time.\n");
5257         status = cli_ntcreate(cli1, fname, 0, FILE_WRITE_DATA, FILE_ATTRIBUTE_NORMAL,
5258                                 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
5259                                 FILE_OVERWRITE_IF, 0, 0, &fnum1);
5260         if (!NT_STATUS_IS_OK(status)) {
5261                 printf("TEST #8 open of %s failed (%s)\n", fname, nt_errstr(status));
5262                 correct = false;
5263                 goto out;
5264         }
5265
5266         /* Write to ensure we have to update the file time. */
5267         status = cli_writeall(cli1, fnum1, 0, (const uint8_t *)"TEST DATA\n", 0, 10,
5268                               NULL);
5269         if (!NT_STATUS_IS_OK(status)) {
5270                 printf("TEST #8 cli_write failed: %s\n", nt_errstr(status));
5271                 correct = false;
5272                 goto out;
5273         }
5274
5275         status = cli_close(cli1, fnum1);
5276         if (!NT_STATUS_IS_OK(status)) {
5277                 printf("TEST #8 close of %s failed (%s)\n", fname, nt_errstr(status));
5278                 correct = false;
5279         }
5280
5281   out:
5282
5283         if (!torture_close_connection(cli1)) {
5284                 correct = False;
5285         }
5286         if (!torture_close_connection(cli2)) {
5287                 correct = False;
5288         }
5289
5290         return correct;
5291 }
5292
5293 NTSTATUS torture_setup_unix_extensions(struct cli_state *cli)
5294 {
5295         uint16 major, minor;
5296         uint32 caplow, caphigh;
5297         NTSTATUS status;
5298
5299         if (!SERVER_HAS_UNIX_CIFS(cli)) {
5300                 printf("Server doesn't support UNIX CIFS extensions.\n");
5301                 return NT_STATUS_NOT_SUPPORTED;
5302         }
5303
5304         status = cli_unix_extensions_version(cli, &major, &minor, &caplow,
5305                                              &caphigh);
5306         if (!NT_STATUS_IS_OK(status)) {
5307                 printf("Server didn't return UNIX CIFS extensions: %s\n",
5308                        nt_errstr(status));
5309                 return status;
5310         }
5311
5312         status = cli_set_unix_extensions_capabilities(cli, major, minor,
5313                                                       caplow, caphigh);
5314         if (!NT_STATUS_IS_OK(status)) {
5315                 printf("Server doesn't support setting UNIX CIFS extensions: "
5316                        "%s.\n", nt_errstr(status));
5317                 return status;
5318         }
5319
5320         return NT_STATUS_OK;
5321 }
5322
5323 /*
5324   Test POSIX open /mkdir calls.
5325  */
5326 static bool run_simple_posix_open_test(int dummy)
5327 {
5328         static struct cli_state *cli1;
5329         const char *fname = "posix:file";
5330         const char *hname = "posix:hlink";
5331         const char *sname = "posix:symlink";
5332         const char *dname = "posix:dir";
5333         char buf[10];
5334         char namebuf[11];
5335         uint16_t fnum1 = (uint16_t)-1;
5336         SMB_STRUCT_STAT sbuf;
5337         bool correct = false;
5338         NTSTATUS status;
5339         size_t nread;
5340
5341         printf("Starting simple POSIX open test\n");
5342
5343         if (!torture_open_connection(&cli1, 0)) {
5344                 return false;
5345         }
5346
5347         cli_sockopt(cli1, sockops);
5348
5349         status = torture_setup_unix_extensions(cli1);
5350         if (!NT_STATUS_IS_OK(status)) {
5351                 return false;
5352         }
5353
5354         cli_setatr(cli1, fname, 0, 0);
5355         cli_posix_unlink(cli1, fname);
5356         cli_setatr(cli1, dname, 0, 0);
5357         cli_posix_rmdir(cli1, dname);
5358         cli_setatr(cli1, hname, 0, 0);
5359         cli_posix_unlink(cli1, hname);
5360         cli_setatr(cli1, sname, 0, 0);
5361         cli_posix_unlink(cli1, sname);
5362
5363         /* Create a directory. */
5364         status = cli_posix_mkdir(cli1, dname, 0777);
5365         if (!NT_STATUS_IS_OK(status)) {
5366                 printf("POSIX mkdir of %s failed (%s)\n", dname, nt_errstr(status));
5367                 goto out;
5368         }
5369
5370         status = cli_posix_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL,
5371                                 0600, &fnum1);
5372         if (!NT_STATUS_IS_OK(status)) {
5373                 printf("POSIX create of %s failed (%s)\n", fname, nt_errstr(status));
5374                 goto out;
5375         }
5376
5377         /* Test ftruncate - set file size. */
5378         status = cli_ftruncate(cli1, fnum1, 1000);
5379         if (!NT_STATUS_IS_OK(status)) {
5380                 printf("ftruncate failed (%s)\n", nt_errstr(status));
5381                 goto out;
5382         }
5383
5384         /* Ensure st_size == 1000 */
5385         status = cli_posix_stat(cli1, fname, &sbuf);
5386         if (!NT_STATUS_IS_OK(status)) {
5387                 printf("stat failed (%s)\n", nt_errstr(status));
5388                 goto out;
5389         }
5390
5391         if (sbuf.st_ex_size != 1000) {
5392                 printf("ftruncate - stat size (%u) != 1000\n", (unsigned int)sbuf.st_ex_size);
5393                 goto out;
5394         }
5395
5396         /* Test ftruncate - set file size back to zero. */
5397         status = cli_ftruncate(cli1, fnum1, 0);
5398         if (!NT_STATUS_IS_OK(status)) {
5399                 printf("ftruncate failed (%s)\n", nt_errstr(status));
5400                 goto out;
5401         }
5402
5403         status = cli_close(cli1, fnum1);
5404         if (!NT_STATUS_IS_OK(status)) {
5405                 printf("close failed (%s)\n", nt_errstr(status));
5406                 goto out;
5407         }
5408
5409         /* Now open the file again for read only. */
5410         status = cli_posix_open(cli1, fname, O_RDONLY, 0, &fnum1);
5411         if (!NT_STATUS_IS_OK(status)) {
5412                 printf("POSIX open of %s failed (%s)\n", fname, nt_errstr(status));
5413                 goto out;
5414         }
5415
5416         /* Now unlink while open. */
5417         status = cli_posix_unlink(cli1, fname);
5418         if (!NT_STATUS_IS_OK(status)) {
5419                 printf("POSIX unlink of %s failed (%s)\n", fname, nt_errstr(status));
5420                 goto out;
5421         }
5422
5423         status = cli_close(cli1, fnum1);
5424         if (!NT_STATUS_IS_OK(status)) {
5425                 printf("close(2) failed (%s)\n", nt_errstr(status));
5426                 goto out;
5427         }
5428
5429         /* Ensure the file has gone. */
5430         status = cli_posix_open(cli1, fname, O_RDONLY, 0, &fnum1);
5431         if (NT_STATUS_IS_OK(status)) {
5432                 printf("POSIX open of %s succeeded, should have been deleted.\n", fname);
5433                 goto out;
5434         }
5435
5436         /* Create again to test open with O_TRUNC. */
5437         status = cli_posix_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, 0600, &fnum1);
5438         if (!NT_STATUS_IS_OK(status)) {
5439                 printf("POSIX create of %s failed (%s)\n", fname, nt_errstr(status));
5440                 goto out;
5441         }
5442
5443         /* Test ftruncate - set file size. */
5444         status = cli_ftruncate(cli1, fnum1, 1000);
5445         if (!NT_STATUS_IS_OK(status)) {
5446                 printf("ftruncate failed (%s)\n", nt_errstr(status));
5447                 goto out;
5448         }
5449
5450         /* Ensure st_size == 1000 */
5451         status = cli_posix_stat(cli1, fname, &sbuf);
5452         if (!NT_STATUS_IS_OK(status)) {
5453                 printf("stat failed (%s)\n", nt_errstr(status));
5454                 goto out;
5455         }
5456
5457         if (sbuf.st_ex_size != 1000) {
5458                 printf("ftruncate - stat size (%u) != 1000\n", (unsigned int)sbuf.st_ex_size);
5459                 goto out;
5460         }
5461
5462         status = cli_close(cli1, fnum1);
5463         if (!NT_STATUS_IS_OK(status)) {
5464                 printf("close(2) failed (%s)\n", nt_errstr(status));
5465                 goto out;
5466         }
5467
5468         /* Re-open with O_TRUNC. */
5469         status = cli_posix_open(cli1, fname, O_WRONLY|O_TRUNC, 0600, &fnum1);
5470         if (!NT_STATUS_IS_OK(status)) {
5471                 printf("POSIX create of %s failed (%s)\n", fname, nt_errstr(status));
5472                 goto out;
5473         }
5474
5475         /* Ensure st_size == 0 */
5476         status = cli_posix_stat(cli1, fname, &sbuf);
5477         if (!NT_STATUS_IS_OK(status)) {
5478                 printf("stat failed (%s)\n", nt_errstr(status));
5479                 goto out;
5480         }
5481
5482         if (sbuf.st_ex_size != 0) {
5483                 printf("O_TRUNC - stat size (%u) != 0\n", (unsigned int)sbuf.st_ex_size);
5484                 goto out;
5485         }
5486
5487         status = cli_close(cli1, fnum1);
5488         if (!NT_STATUS_IS_OK(status)) {
5489                 printf("close failed (%s)\n", nt_errstr(status));
5490                 goto out;
5491         }
5492
5493         status = cli_posix_unlink(cli1, fname);
5494         if (!NT_STATUS_IS_OK(status)) {
5495                 printf("POSIX unlink of %s failed (%s)\n", fname, nt_errstr(status));
5496                 goto out;
5497         }
5498
5499         status = cli_posix_open(cli1, dname, O_RDONLY, 0, &fnum1);
5500         if (!NT_STATUS_IS_OK(status)) {
5501                 printf("POSIX open directory O_RDONLY of %s failed (%s)\n",
5502                         dname, nt_errstr(status));
5503                 goto out;
5504         }
5505
5506         cli_close(cli1, fnum1);
5507
5508         /* What happens when we try and POSIX open a directory for write ? */
5509         status = cli_posix_open(cli1, dname, O_RDWR, 0, &fnum1);
5510         if (NT_STATUS_IS_OK(status)) {
5511                 printf("POSIX open of directory %s succeeded, should have failed.\n", fname);
5512                 goto out;
5513         } else {
5514                 if (!check_both_error(__LINE__, status, ERRDOS, EISDIR,
5515                                 NT_STATUS_FILE_IS_A_DIRECTORY)) {
5516                         goto out;
5517                 }
5518         }
5519
5520         /* Create the file. */
5521         status = cli_posix_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL,
5522                                 0600, &fnum1);
5523         if (!NT_STATUS_IS_OK(status)) {
5524                 printf("POSIX create of %s failed (%s)\n", fname, nt_errstr(status));
5525                 goto out;
5526         }
5527
5528         /* Write some data into it. */
5529         status = cli_writeall(cli1, fnum1, 0, (const uint8_t *)"TEST DATA\n", 0, 10,
5530                               NULL);
5531         if (!NT_STATUS_IS_OK(status)) {
5532                 printf("cli_write failed: %s\n", nt_errstr(status));
5533                 goto out;
5534         }
5535
5536         cli_close(cli1, fnum1);
5537
5538         /* Now create a hardlink. */
5539         status = cli_posix_hardlink(cli1, fname, hname);
5540         if (!NT_STATUS_IS_OK(status)) {
5541                 printf("POSIX hardlink of %s failed (%s)\n", hname, nt_errstr(status));
5542                 goto out;
5543         }
5544
5545         /* Now create a symlink. */
5546         status = cli_posix_symlink(cli1, fname, sname);
5547         if (!NT_STATUS_IS_OK(status)) {
5548                 printf("POSIX symlink of %s failed (%s)\n", sname, nt_errstr(status));
5549                 goto out;
5550         }
5551
5552         /* Open the hardlink for read. */
5553         status = cli_posix_open(cli1, hname, O_RDONLY, 0, &fnum1);
5554         if (!NT_STATUS_IS_OK(status)) {
5555                 printf("POSIX open of %s failed (%s)\n", hname, nt_errstr(status));
5556                 goto out;
5557         }
5558
5559         status = cli_read(cli1, fnum1, buf, 0, 10, &nread);
5560         if (!NT_STATUS_IS_OK(status)) {
5561                 printf("POSIX read of %s failed (%s)\n", hname,
5562                        nt_errstr(status));
5563                 goto out;
5564         } else if (nread != 10) {
5565                 printf("POSIX read of %s failed. Received %ld, expected %d\n",
5566                        hname, (unsigned long)nread, 10);
5567                 goto out;
5568         }
5569
5570         if (memcmp(buf, "TEST DATA\n", 10)) {
5571                 printf("invalid data read from hardlink\n");
5572                 goto out;
5573         }
5574
5575         /* Do a POSIX lock/unlock. */
5576         status = cli_posix_lock(cli1, fnum1, 0, 100, true, READ_LOCK);
5577         if (!NT_STATUS_IS_OK(status)) {
5578                 printf("POSIX lock failed %s\n", nt_errstr(status));
5579                 goto out;
5580         }
5581
5582         /* Punch a hole in the locked area. */
5583         status = cli_posix_unlock(cli1, fnum1, 10, 80);
5584         if (!NT_STATUS_IS_OK(status)) {
5585                 printf("POSIX unlock failed %s\n", nt_errstr(status));
5586                 goto out;
5587         }
5588
5589         cli_close(cli1, fnum1);
5590
5591         /* Open the symlink for read - this should fail. A POSIX
5592            client should not be doing opens on a symlink. */
5593         status = cli_posix_open(cli1, sname, O_RDONLY, 0, &fnum1);
5594         if (NT_STATUS_IS_OK(status)) {
5595                 printf("POSIX open of %s succeeded (should have failed)\n", sname);
5596                 goto out;
5597         } else {
5598                 if (!check_both_error(__LINE__, status, ERRDOS, ERRbadpath,
5599                                 NT_STATUS_OBJECT_PATH_NOT_FOUND)) {
5600                         printf("POSIX open of %s should have failed "
5601                                 "with NT_STATUS_OBJECT_PATH_NOT_FOUND, "
5602                                 "failed with %s instead.\n",
5603                                 sname, nt_errstr(status));
5604                         goto out;
5605                 }
5606         }
5607
5608         status = cli_posix_readlink(cli1, sname, namebuf, sizeof(namebuf));
5609         if (!NT_STATUS_IS_OK(status)) {
5610                 printf("POSIX readlink on %s failed (%s)\n", sname, nt_errstr(status));
5611                 goto out;
5612         }
5613
5614         if (strcmp(namebuf, fname) != 0) {
5615                 printf("POSIX readlink on %s failed to match name %s (read %s)\n",
5616                         sname, fname, namebuf);
5617                 goto out;
5618         }
5619
5620         status = cli_posix_rmdir(cli1, dname);
5621         if (!NT_STATUS_IS_OK(status)) {
5622                 printf("POSIX rmdir failed (%s)\n", nt_errstr(status));
5623                 goto out;
5624         }
5625
5626         printf("Simple POSIX open test passed\n");
5627         correct = true;
5628
5629   out:
5630
5631         if (fnum1 != (uint16_t)-1) {
5632                 cli_close(cli1, fnum1);
5633                 fnum1 = (uint16_t)-1;
5634         }
5635
5636         cli_setatr(cli1, sname, 0, 0);
5637         cli_posix_unlink(cli1, sname);
5638         cli_setatr(cli1, hname, 0, 0);
5639         cli_posix_unlink(cli1, hname);
5640         cli_setatr(cli1, fname, 0, 0);
5641         cli_posix_unlink(cli1, fname);
5642         cli_setatr(cli1, dname, 0, 0);
5643         cli_posix_rmdir(cli1, dname);
5644
5645         if (!torture_close_connection(cli1)) {
5646                 correct = false;
5647         }
5648
5649         return correct;
5650 }
5651
5652
5653 static uint32 open_attrs_table[] = {
5654                 FILE_ATTRIBUTE_NORMAL,
5655                 FILE_ATTRIBUTE_ARCHIVE,
5656                 FILE_ATTRIBUTE_READONLY,
5657                 FILE_ATTRIBUTE_HIDDEN,
5658                 FILE_ATTRIBUTE_SYSTEM,
5659
5660                 FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY,
5661                 FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN,
5662                 FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM,
5663                 FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN,
5664                 FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM,
5665                 FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN|FILE_ATTRIBUTE_SYSTEM,
5666
5667                 FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN,
5668                 FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM,
5669                 FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN|FILE_ATTRIBUTE_SYSTEM,
5670                 FILE_ATTRIBUTE_HIDDEN,FILE_ATTRIBUTE_SYSTEM,
5671 };
5672
5673 struct trunc_open_results {
5674         unsigned int num;
5675         uint32 init_attr;
5676         uint32 trunc_attr;
5677         uint32 result_attr;
5678 };
5679
5680 static struct trunc_open_results attr_results[] = {
5681         { 0, FILE_ATTRIBUTE_NORMAL, FILE_ATTRIBUTE_NORMAL, FILE_ATTRIBUTE_ARCHIVE },
5682         { 1, FILE_ATTRIBUTE_NORMAL, FILE_ATTRIBUTE_ARCHIVE, FILE_ATTRIBUTE_ARCHIVE },
5683         { 2, FILE_ATTRIBUTE_NORMAL, FILE_ATTRIBUTE_READONLY, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY },
5684         { 16, FILE_ATTRIBUTE_ARCHIVE, FILE_ATTRIBUTE_NORMAL, FILE_ATTRIBUTE_ARCHIVE },
5685         { 17, FILE_ATTRIBUTE_ARCHIVE, FILE_ATTRIBUTE_ARCHIVE, FILE_ATTRIBUTE_ARCHIVE },
5686         { 18, FILE_ATTRIBUTE_ARCHIVE, FILE_ATTRIBUTE_READONLY, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY },
5687         { 51, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN },
5688         { 54, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN },
5689         { 56, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN },
5690         { 68, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM },
5691         { 71, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM },
5692         { 73, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM },
5693         { 99, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_HIDDEN,FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN },
5694         { 102, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN },
5695         { 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 },
5696         { 116, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM },
5697         { 119,  FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM,  FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM },
5698         { 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 },
5699         { 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 },
5700         { 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 },
5701         { 227, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN },
5702         { 230, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN },
5703         { 232, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN },
5704         { 244, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM },
5705         { 247, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM },
5706         { 249, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM }
5707 };
5708
5709 static bool run_openattrtest(int dummy)
5710 {
5711         static struct cli_state *cli1;
5712         const char *fname = "\\openattr.file";
5713         uint16_t fnum1;
5714         bool correct = True;
5715         uint16 attr;
5716         unsigned int i, j, k, l;
5717         NTSTATUS status;
5718
5719         printf("starting open attr test\n");
5720
5721         if (!torture_open_connection(&cli1, 0)) {
5722                 return False;
5723         }
5724
5725         cli_sockopt(cli1, sockops);
5726
5727         for (k = 0, i = 0; i < sizeof(open_attrs_table)/sizeof(uint32); i++) {
5728                 cli_setatr(cli1, fname, 0, 0);
5729                 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
5730
5731                 status = cli_ntcreate(cli1, fname, 0, FILE_WRITE_DATA,
5732                                        open_attrs_table[i], FILE_SHARE_NONE,
5733                                        FILE_OVERWRITE_IF, 0, 0, &fnum1);
5734                 if (!NT_STATUS_IS_OK(status)) {
5735                         printf("open %d (1) of %s failed (%s)\n", i, fname, nt_errstr(status));
5736                         return False;
5737                 }
5738
5739                 status = cli_close(cli1, fnum1);
5740                 if (!NT_STATUS_IS_OK(status)) {
5741                         printf("close %d (1) of %s failed (%s)\n", i, fname, nt_errstr(status));
5742                         return False;
5743                 }
5744
5745                 for (j = 0; j < sizeof(open_attrs_table)/sizeof(uint32); j++) {
5746                         status = cli_ntcreate(cli1, fname, 0,
5747                                               FILE_READ_DATA|FILE_WRITE_DATA,
5748                                               open_attrs_table[j],
5749                                               FILE_SHARE_NONE, FILE_OVERWRITE,
5750                                               0, 0, &fnum1);
5751                         if (!NT_STATUS_IS_OK(status)) {
5752                                 for (l = 0; l < sizeof(attr_results)/sizeof(struct trunc_open_results); l++) {
5753                                         if (attr_results[l].num == k) {
5754                                                 printf("[%d] trunc open 0x%x -> 0x%x of %s failed - should have succeeded !(0x%x:%s)\n",
5755                                                                 k, open_attrs_table[i],
5756                                                                 open_attrs_table[j],
5757                                                                 fname, NT_STATUS_V(status), nt_errstr(status));
5758                                                 correct = False;
5759                                         }
5760                                 }
5761
5762                                 if (!NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED)) {
5763                                         printf("[%d] trunc open 0x%x -> 0x%x failed with wrong error code %s\n",
5764                                                         k, open_attrs_table[i], open_attrs_table[j],
5765                                                         nt_errstr(status));
5766                                         correct = False;
5767                                 }
5768 #if 0
5769                                 printf("[%d] trunc open 0x%x -> 0x%x failed\n", k, open_attrs_table[i], open_attrs_table[j]);
5770 #endif
5771                                 k++;
5772                                 continue;
5773                         }
5774
5775                         status = cli_close(cli1, fnum1);
5776                         if (!NT_STATUS_IS_OK(status)) {
5777                                 printf("close %d (2) of %s failed (%s)\n", j, fname, nt_errstr(status));
5778                                 return False;
5779                         }
5780
5781                         status = cli_getatr(cli1, fname, &attr, NULL, NULL);
5782                         if (!NT_STATUS_IS_OK(status)) {
5783                                 printf("getatr(2) failed (%s)\n", nt_errstr(status));
5784                                 return False;
5785                         }
5786
5787 #if 0
5788                         printf("[%d] getatr check [0x%x] trunc [0x%x] got attr 0x%x\n",
5789                                         k,  open_attrs_table[i],  open_attrs_table[j], attr );
5790 #endif
5791
5792                         for (l = 0; l < sizeof(attr_results)/sizeof(struct trunc_open_results); l++) {
5793                                 if (attr_results[l].num == k) {
5794                                         if (attr != attr_results[l].result_attr ||
5795                                                         open_attrs_table[i] != attr_results[l].init_attr ||
5796                                                         open_attrs_table[j] != attr_results[l].trunc_attr) {
5797                                                 printf("getatr check failed. [0x%x] trunc [0x%x] got attr 0x%x, should be 0x%x\n",
5798                                                 open_attrs_table[i],
5799                                                 open_attrs_table[j],
5800                                                 (unsigned int)attr,
5801                                                 attr_results[l].result_attr);
5802                                                 correct = False;
5803                                         }
5804                                         break;
5805                                 }
5806                         }
5807                         k++;
5808                 }
5809         }
5810
5811         cli_setatr(cli1, fname, 0, 0);
5812         cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
5813
5814         printf("open attr test %s.\n", correct ? "passed" : "failed");
5815
5816         if (!torture_close_connection(cli1)) {
5817                 correct = False;
5818         }
5819         return correct;
5820 }
5821
5822 static NTSTATUS list_fn(const char *mnt, struct file_info *finfo,
5823                     const char *name, void *state)
5824 {
5825         int *matched = (int *)state;
5826         if (matched != NULL) {
5827                 *matched += 1;
5828         }
5829         return NT_STATUS_OK;
5830 }
5831
5832 /*
5833   test directory listing speed
5834  */
5835 static bool run_dirtest(int dummy)
5836 {
5837         int i;
5838         static struct cli_state *cli;
5839         uint16_t fnum;
5840         struct timeval core_start;
5841         bool correct = True;
5842         int matched;
5843
5844         printf("starting directory test\n");
5845
5846         if (!torture_open_connection(&cli, 0)) {
5847                 return False;
5848         }
5849
5850         cli_sockopt(cli, sockops);
5851
5852         srandom(0);
5853         for (i=0;i<torture_numops;i++) {
5854                 fstring fname;
5855                 slprintf(fname, sizeof(fname), "\\%x", (int)random());
5856                 if (!NT_STATUS_IS_OK(cli_open(cli, fname, O_RDWR|O_CREAT, DENY_NONE, &fnum))) {
5857                         fprintf(stderr,"Failed to open %s\n", fname);
5858                         return False;
5859                 }
5860                 cli_close(cli, fnum);
5861         }
5862
5863         core_start = timeval_current();
5864
5865         matched = 0;
5866         cli_list(cli, "a*.*", 0, list_fn, &matched);
5867         printf("Matched %d\n", matched);
5868
5869         matched = 0;
5870         cli_list(cli, "b*.*", 0, list_fn, &matched);
5871         printf("Matched %d\n", matched);
5872
5873         matched = 0;
5874         cli_list(cli, "xyzabc", 0, list_fn, &matched);
5875         printf("Matched %d\n", matched);
5876
5877         printf("dirtest core %g seconds\n", timeval_elapsed(&core_start));
5878
5879         srandom(0);
5880         for (i=0;i<torture_numops;i++) {
5881                 fstring fname;
5882                 slprintf(fname, sizeof(fname), "\\%x", (int)random());
5883                 cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
5884         }
5885
5886         if (!torture_close_connection(cli)) {
5887                 correct = False;
5888         }
5889
5890         printf("finished dirtest\n");
5891
5892         return correct;
5893 }
5894
5895 static NTSTATUS del_fn(const char *mnt, struct file_info *finfo, const char *mask,
5896                    void *state)
5897 {
5898         struct cli_state *pcli = (struct cli_state *)state;
5899         fstring fname;
5900         slprintf(fname, sizeof(fname), "\\LISTDIR\\%s", finfo->name);
5901
5902         if (strcmp(finfo->name, ".") == 0 || strcmp(finfo->name, "..") == 0)
5903                 return NT_STATUS_OK;
5904
5905         if (finfo->mode & FILE_ATTRIBUTE_DIRECTORY) {
5906                 if (!NT_STATUS_IS_OK(cli_rmdir(pcli, fname)))
5907                         printf("del_fn: failed to rmdir %s\n,", fname );
5908         } else {
5909                 if (!NT_STATUS_IS_OK(cli_unlink(pcli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN)))
5910                         printf("del_fn: failed to unlink %s\n,", fname );
5911         }
5912         return NT_STATUS_OK;
5913 }
5914
5915
5916 /*
5917   sees what IOCTLs are supported
5918  */
5919 bool torture_ioctl_test(int dummy)
5920 {
5921         static struct cli_state *cli;
5922         uint16_t device, function;
5923         uint16_t fnum;
5924         const char *fname = "\\ioctl.dat";
5925         DATA_BLOB blob;
5926         NTSTATUS status;
5927
5928         if (!torture_open_connection(&cli, 0)) {
5929                 return False;
5930         }
5931
5932         printf("starting ioctl test\n");
5933
5934         cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
5935
5936         status = cli_open(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum);
5937         if (!NT_STATUS_IS_OK(status)) {
5938                 printf("open of %s failed (%s)\n", fname, nt_errstr(status));
5939                 return False;
5940         }
5941
5942         status = cli_raw_ioctl(cli, fnum, 0x2d0000 | (0x0420<<2), &blob);
5943         printf("ioctl device info: %s\n", nt_errstr(status));
5944
5945         status = cli_raw_ioctl(cli, fnum, IOCTL_QUERY_JOB_INFO, &blob);
5946         printf("ioctl job info: %s\n", nt_errstr(status));
5947
5948         for (device=0;device<0x100;device++) {
5949                 printf("ioctl test with device = 0x%x\n", device);
5950                 for (function=0;function<0x100;function++) {
5951                         uint32 code = (device<<16) | function;
5952
5953                         status = cli_raw_ioctl(cli, fnum, code, &blob);
5954
5955                         if (NT_STATUS_IS_OK(status)) {
5956                                 printf("ioctl 0x%x OK : %d bytes\n", (int)code,
5957                                        (int)blob.length);
5958                                 data_blob_free(&blob);
5959                         }
5960                 }
5961         }
5962
5963         if (!torture_close_connection(cli)) {
5964                 return False;
5965         }
5966
5967         return True;
5968 }
5969
5970
5971 /*
5972   tries varients of chkpath
5973  */
5974 bool torture_chkpath_test(int dummy)
5975 {
5976         static struct cli_state *cli;
5977         uint16_t fnum;
5978         bool ret;
5979         NTSTATUS status;
5980
5981         if (!torture_open_connection(&cli, 0)) {
5982                 return False;
5983         }
5984
5985         printf("starting chkpath test\n");
5986
5987         /* cleanup from an old run */
5988         cli_rmdir(cli, "\\chkpath.dir\\dir2");
5989         cli_unlink(cli, "\\chkpath.dir\\*", FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
5990         cli_rmdir(cli, "\\chkpath.dir");
5991
5992         status = cli_mkdir(cli, "\\chkpath.dir");
5993         if (!NT_STATUS_IS_OK(status)) {
5994                 printf("mkdir1 failed : %s\n", nt_errstr(status));
5995                 return False;
5996         }
5997
5998         status = cli_mkdir(cli, "\\chkpath.dir\\dir2");
5999         if (!NT_STATUS_IS_OK(status)) {
6000                 printf("mkdir2 failed : %s\n", nt_errstr(status));
6001                 return False;
6002         }
6003
6004         status = cli_open(cli, "\\chkpath.dir\\foo.txt", O_RDWR|O_CREAT|O_EXCL,
6005                           DENY_NONE, &fnum);
6006         if (!NT_STATUS_IS_OK(status)) {
6007                 printf("open1 failed (%s)\n", nt_errstr(status));
6008                 return False;
6009         }
6010         cli_close(cli, fnum);
6011
6012         status = cli_chkpath(cli, "\\chkpath.dir");
6013         if (!NT_STATUS_IS_OK(status)) {
6014                 printf("chkpath1 failed: %s\n", nt_errstr(status));
6015                 ret = False;
6016         }
6017
6018         status = cli_chkpath(cli, "\\chkpath.dir\\dir2");
6019         if (!NT_STATUS_IS_OK(status)) {
6020                 printf("chkpath2 failed: %s\n", nt_errstr(status));
6021                 ret = False;
6022         }
6023
6024         status = cli_chkpath(cli, "\\chkpath.dir\\foo.txt");
6025         if (!NT_STATUS_IS_OK(status)) {
6026                 ret = check_error(__LINE__, status, ERRDOS, ERRbadpath,
6027                                   NT_STATUS_NOT_A_DIRECTORY);
6028         } else {
6029                 printf("* chkpath on a file should fail\n");
6030                 ret = False;
6031         }
6032
6033         status = cli_chkpath(cli, "\\chkpath.dir\\bar.txt");
6034         if (!NT_STATUS_IS_OK(status)) {
6035                 ret = check_error(__LINE__, status, ERRDOS, ERRbadfile,
6036                                   NT_STATUS_OBJECT_NAME_NOT_FOUND);
6037         } else {
6038                 printf("* chkpath on a non existant file should fail\n");
6039                 ret = False;
6040         }
6041
6042         status = cli_chkpath(cli, "\\chkpath.dir\\dirxx\\bar.txt");
6043         if (!NT_STATUS_IS_OK(status)) {
6044                 ret = check_error(__LINE__, status, ERRDOS, ERRbadpath,
6045                                   NT_STATUS_OBJECT_PATH_NOT_FOUND);
6046         } else {
6047                 printf("* chkpath on a non existent component should fail\n");
6048                 ret = False;
6049         }
6050
6051         cli_rmdir(cli, "\\chkpath.dir\\dir2");
6052         cli_unlink(cli, "\\chkpath.dir\\*", FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
6053         cli_rmdir(cli, "\\chkpath.dir");
6054
6055         if (!torture_close_connection(cli)) {
6056                 return False;
6057         }
6058
6059         return ret;
6060 }
6061
6062 static bool run_eatest(int dummy)
6063 {
6064         static struct cli_state *cli;
6065         const char *fname = "\\eatest.txt";
6066         bool correct = True;
6067         uint16_t fnum;
6068         int i;
6069         size_t num_eas;
6070         struct ea_struct *ea_list = NULL;
6071         TALLOC_CTX *mem_ctx = talloc_init("eatest");
6072         NTSTATUS status;
6073
6074         printf("starting eatest\n");
6075
6076         if (!torture_open_connection(&cli, 0)) {
6077                 talloc_destroy(mem_ctx);
6078                 return False;
6079         }
6080
6081         cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
6082
6083         status = cli_ntcreate(cli, fname, 0,
6084                               FIRST_DESIRED_ACCESS, FILE_ATTRIBUTE_ARCHIVE,
6085                               FILE_SHARE_NONE, FILE_OVERWRITE_IF,
6086                               0x4044, 0, &fnum);
6087         if (!NT_STATUS_IS_OK(status)) {
6088                 printf("open failed - %s\n", nt_errstr(status));
6089                 talloc_destroy(mem_ctx);
6090                 return False;
6091         }
6092
6093         for (i = 0; i < 10; i++) {
6094                 fstring ea_name, ea_val;
6095
6096                 slprintf(ea_name, sizeof(ea_name), "EA_%d", i);
6097                 memset(ea_val, (char)i+1, i+1);
6098                 status = cli_set_ea_fnum(cli, fnum, ea_name, ea_val, i+1);
6099                 if (!NT_STATUS_IS_OK(status)) {
6100                         printf("ea_set of name %s failed - %s\n", ea_name,
6101                                nt_errstr(status));
6102                         talloc_destroy(mem_ctx);
6103                         return False;
6104                 }
6105         }
6106
6107         cli_close(cli, fnum);
6108         for (i = 0; i < 10; i++) {
6109                 fstring ea_name, ea_val;
6110
6111                 slprintf(ea_name, sizeof(ea_name), "EA_%d", i+10);
6112                 memset(ea_val, (char)i+1, i+1);
6113                 status = cli_set_ea_path(cli, fname, ea_name, ea_val, i+1);
6114                 if (!NT_STATUS_IS_OK(status)) {
6115                         printf("ea_set of name %s failed - %s\n", ea_name,
6116                                nt_errstr(status));
6117                         talloc_destroy(mem_ctx);
6118                         return False;
6119                 }
6120         }
6121
6122         status = cli_get_ea_list_path(cli, fname, mem_ctx, &num_eas, &ea_list);
6123         if (!NT_STATUS_IS_OK(status)) {
6124                 printf("ea_get list failed - %s\n", nt_errstr(status));
6125                 correct = False;
6126         }
6127
6128         printf("num_eas = %d\n", (int)num_eas);
6129
6130         if (num_eas != 20) {
6131                 printf("Should be 20 EA's stored... failing.\n");
6132                 correct = False;
6133         }
6134
6135         for (i = 0; i < num_eas; i++) {
6136                 printf("%d: ea_name = %s. Val = ", i, ea_list[i].name);
6137                 dump_data(0, ea_list[i].value.data,
6138                           ea_list[i].value.length);
6139         }
6140
6141         /* Setting EA's to zero length deletes them. Test this */
6142         printf("Now deleting all EA's - case indepenent....\n");
6143
6144 #if 1
6145         cli_set_ea_path(cli, fname, "", "", 0);
6146 #else
6147         for (i = 0; i < 20; i++) {
6148                 fstring ea_name;
6149                 slprintf(ea_name, sizeof(ea_name), "ea_%d", i);
6150                 status = cli_set_ea_path(cli, fname, ea_name, "", 0);
6151                 if (!NT_STATUS_IS_OK(status)) {
6152                         printf("ea_set of name %s failed - %s\n", ea_name,
6153                                nt_errstr(status));
6154                         talloc_destroy(mem_ctx);
6155                         return False;
6156                 }
6157         }
6158 #endif
6159
6160         status = cli_get_ea_list_path(cli, fname, mem_ctx, &num_eas, &ea_list);
6161         if (!NT_STATUS_IS_OK(status)) {
6162                 printf("ea_get list failed - %s\n", nt_errstr(status));
6163                 correct = False;
6164         }
6165
6166         printf("num_eas = %d\n", (int)num_eas);
6167         for (i = 0; i < num_eas; i++) {
6168                 printf("%d: ea_name = %s. Val = ", i, ea_list[i].name);
6169                 dump_data(0, ea_list[i].value.data,
6170                           ea_list[i].value.length);
6171         }
6172
6173         if (num_eas != 0) {
6174                 printf("deleting EA's failed.\n");
6175                 correct = False;
6176         }
6177
6178         /* Try and delete a non existant EA. */
6179         status = cli_set_ea_path(cli, fname, "foo", "", 0);
6180         if (!NT_STATUS_IS_OK(status)) {
6181                 printf("deleting non-existant EA 'foo' should succeed. %s\n",
6182                        nt_errstr(status));
6183                 correct = False;
6184         }
6185
6186         talloc_destroy(mem_ctx);
6187         if (!torture_close_connection(cli)) {
6188                 correct = False;
6189         }
6190
6191         return correct;
6192 }
6193
6194 static bool run_dirtest1(int dummy)
6195 {
6196         int i;
6197         static struct cli_state *cli;
6198         uint16_t fnum;
6199         int num_seen;
6200         bool correct = True;
6201
6202         printf("starting directory test\n");
6203
6204         if (!torture_open_connection(&cli, 0)) {
6205                 return False;
6206         }
6207
6208         cli_sockopt(cli, sockops);
6209
6210         cli_list(cli, "\\LISTDIR\\*", 0, del_fn, cli);
6211         cli_list(cli, "\\LISTDIR\\*", FILE_ATTRIBUTE_DIRECTORY, del_fn, cli);
6212         cli_rmdir(cli, "\\LISTDIR");
6213         cli_mkdir(cli, "\\LISTDIR");
6214
6215         /* Create 1000 files and 1000 directories. */
6216         for (i=0;i<1000;i++) {
6217                 fstring fname;
6218                 slprintf(fname, sizeof(fname), "\\LISTDIR\\f%d", i);
6219                 if (!NT_STATUS_IS_OK(cli_ntcreate(cli, fname, 0, GENERIC_ALL_ACCESS, FILE_ATTRIBUTE_ARCHIVE,
6220                                    FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OVERWRITE_IF, 0, 0, &fnum))) {
6221                         fprintf(stderr,"Failed to open %s\n", fname);
6222                         return False;
6223                 }
6224                 cli_close(cli, fnum);
6225         }
6226         for (i=0;i<1000;i++) {
6227                 fstring fname;
6228                 slprintf(fname, sizeof(fname), "\\LISTDIR\\d%d", i);
6229                 if (!NT_STATUS_IS_OK(cli_mkdir(cli, fname))) {
6230                         fprintf(stderr,"Failed to open %s\n", fname);
6231                         return False;
6232                 }
6233         }
6234
6235         /* Now ensure that doing an old list sees both files and directories. */
6236         num_seen = 0;
6237         cli_list_old(cli, "\\LISTDIR\\*", FILE_ATTRIBUTE_DIRECTORY, list_fn, &num_seen);
6238         printf("num_seen = %d\n", num_seen );
6239         /* We should see 100 files + 1000 directories + . and .. */
6240         if (num_seen != 2002)
6241                 correct = False;
6242
6243         /* Ensure if we have the "must have" bits we only see the
6244          * relevent entries.
6245          */
6246         num_seen = 0;
6247         cli_list_old(cli, "\\LISTDIR\\*", (FILE_ATTRIBUTE_DIRECTORY<<8)|FILE_ATTRIBUTE_DIRECTORY, list_fn, &num_seen);
6248         printf("num_seen = %d\n", num_seen );
6249         if (num_seen != 1002)
6250                 correct = False;
6251
6252         num_seen = 0;
6253         cli_list_old(cli, "\\LISTDIR\\*", (FILE_ATTRIBUTE_ARCHIVE<<8)|FILE_ATTRIBUTE_DIRECTORY, list_fn, &num_seen);
6254         printf("num_seen = %d\n", num_seen );
6255         if (num_seen != 1000)
6256                 correct = False;
6257
6258         /* Delete everything. */
6259         cli_list(cli, "\\LISTDIR\\*", 0, del_fn, cli);
6260         cli_list(cli, "\\LISTDIR\\*", FILE_ATTRIBUTE_DIRECTORY, del_fn, cli);
6261         cli_rmdir(cli, "\\LISTDIR");
6262
6263 #if 0
6264         printf("Matched %d\n", cli_list(cli, "a*.*", 0, list_fn, NULL));
6265         printf("Matched %d\n", cli_list(cli, "b*.*", 0, list_fn, NULL));
6266         printf("Matched %d\n", cli_list(cli, "xyzabc", 0, list_fn, NULL));
6267 #endif
6268
6269         if (!torture_close_connection(cli)) {
6270                 correct = False;
6271         }
6272
6273         printf("finished dirtest1\n");
6274
6275         return correct;
6276 }
6277
6278 static bool run_error_map_extract(int dummy) {
6279
6280         static struct cli_state *c_dos;
6281         static struct cli_state *c_nt;
6282         NTSTATUS status;
6283
6284         uint32 error;
6285
6286         uint32 errnum;
6287         uint8 errclass;
6288
6289         NTSTATUS nt_status;
6290
6291         fstring user;
6292
6293         /* NT-Error connection */
6294
6295         if (!(c_nt = open_nbt_connection())) {
6296                 return False;
6297         }
6298
6299         c_nt->use_spnego = False;
6300
6301         status = cli_negprot(c_nt);
6302
6303         if (!NT_STATUS_IS_OK(status)) {
6304                 printf("%s rejected the NT-error negprot (%s)\n", host,
6305                        nt_errstr(status));
6306                 cli_shutdown(c_nt);
6307                 return False;
6308         }
6309
6310         status = cli_session_setup(c_nt, "", "", 0, "", 0, workgroup);
6311         if (!NT_STATUS_IS_OK(status)) {
6312                 printf("%s rejected the NT-error initial session setup (%s)\n",host, nt_errstr(status));
6313                 return False;
6314         }
6315
6316         /* DOS-Error connection */
6317
6318         force_dos_errors = true;
6319         if (!(c_dos = open_nbt_connection())) {
6320                 force_dos_errors = false;
6321                 return False;
6322         }
6323         force_dos_errors = false;
6324
6325         c_dos->use_spnego = False;
6326
6327         status = cli_negprot(c_dos);
6328         if (!NT_STATUS_IS_OK(status)) {
6329                 printf("%s rejected the DOS-error negprot (%s)\n", host,
6330                        nt_errstr(status));
6331                 cli_shutdown(c_dos);
6332                 return False;
6333         }
6334
6335         status = cli_session_setup(c_dos, "", "", 0, "", 0, workgroup);
6336         if (!NT_STATUS_IS_OK(status)) {
6337                 printf("%s rejected the DOS-error initial session setup (%s)\n",
6338                         host, nt_errstr(status));
6339                 return False;
6340         }
6341
6342         for (error=(0xc0000000 | 0x1); error < (0xc0000000| 0xFFF); error++) {
6343                 fstr_sprintf(user, "%X", error);
6344
6345                 status = cli_session_setup(c_nt, user,
6346                                            password, strlen(password),
6347                                            password, strlen(password),
6348                                            workgroup);
6349                 if (NT_STATUS_IS_OK(status)) {
6350                         printf("/** Session setup succeeded.  This shouldn't happen...*/\n");
6351                 }
6352
6353                 /* Case #1: 32-bit NT errors */
6354                 if (cli_is_nt_error(c_nt)) {
6355                         nt_status = cli_nt_error(c_nt);
6356                 } else {
6357                         printf("/** Dos error on NT connection! (%s) */\n",
6358                                cli_errstr(c_nt));
6359                         nt_status = NT_STATUS(0xc0000000);
6360                 }
6361
6362                 status = cli_session_setup(c_dos, user,
6363                                            password, strlen(password),
6364                                            password, strlen(password),
6365                                            workgroup);
6366                 if (NT_STATUS_IS_OK(status)) {
6367                         printf("/** Session setup succeeded.  This shouldn't happen...*/\n");
6368                 }
6369
6370                 /* Case #1: 32-bit NT errors */
6371                 if (!cli_is_dos_error(c_dos)) {
6372                         printf("/** NT error on DOS connection! (%s) */\n",
6373                                cli_errstr(c_dos));
6374                         errnum = errclass = 0;
6375                 } else {
6376                         cli_dos_error(c_dos, &errclass, &errnum);
6377                 }
6378
6379                 if (NT_STATUS_V(nt_status) != error) {
6380                         printf("/*\t{ This NT error code was 'sqashed'\n\t from %s to %s \n\t during the session setup }\n*/\n",
6381                                get_nt_error_c_code(talloc_tos(), NT_STATUS(error)),
6382                                get_nt_error_c_code(talloc_tos(), nt_status));
6383                 }
6384
6385                 printf("\t{%s,\t%s,\t%s},\n",
6386                        smb_dos_err_class(errclass),
6387                        smb_dos_err_name(errclass, errnum),
6388                        get_nt_error_c_code(talloc_tos(), NT_STATUS(error)));
6389         }
6390         return True;
6391 }
6392
6393 static bool run_sesssetup_bench(int dummy)
6394 {
6395         static struct cli_state *c;
6396         const char *fname = "\\file.dat";
6397         uint16_t fnum;
6398         NTSTATUS status;
6399         int i;
6400
6401         if (!torture_open_connection(&c, 0)) {
6402                 return false;
6403         }
6404
6405         status = cli_ntcreate(c, fname, 0, GENERIC_ALL_ACCESS|DELETE_ACCESS,
6406                               FILE_ATTRIBUTE_NORMAL, 0, FILE_OVERWRITE_IF,
6407                               FILE_DELETE_ON_CLOSE, 0, &fnum);
6408         if (!NT_STATUS_IS_OK(status)) {
6409                 d_printf("open %s failed: %s\n", fname, nt_errstr(status));
6410                 return false;
6411         }
6412
6413         for (i=0; i<torture_numops; i++) {
6414                 status = cli_session_setup(
6415                         c, username,
6416                         password, strlen(password),
6417                         password, strlen(password),
6418                         workgroup);
6419                 if (!NT_STATUS_IS_OK(status)) {
6420                         d_printf("(%s) cli_session_setup failed: %s\n",
6421                                  __location__, nt_errstr(status));
6422                         return false;
6423                 }
6424
6425                 d_printf("\r%d   ", (int)cli_state_get_uid(c));
6426
6427                 status = cli_ulogoff(c);
6428                 if (!NT_STATUS_IS_OK(status)) {
6429                         d_printf("(%s) cli_ulogoff failed: %s\n",
6430                                  __location__, nt_errstr(status));
6431                         return false;
6432                 }
6433         }
6434
6435         return true;
6436 }
6437
6438 static bool subst_test(const char *str, const char *user, const char *domain,
6439                        uid_t uid, gid_t gid, const char *expected)
6440 {
6441         char *subst;
6442         bool result = true;
6443
6444         subst = talloc_sub_specified(talloc_tos(), str, user, domain, uid, gid);
6445
6446         if (strcmp(subst, expected) != 0) {
6447                 printf("sub_specified(%s, %s, %s, %d, %d) returned [%s], expected "
6448                        "[%s]\n", str, user, domain, (int)uid, (int)gid, subst,
6449                        expected);
6450                 result = false;
6451         }
6452
6453         TALLOC_FREE(subst);
6454         return result;
6455 }
6456
6457 static void chain1_open_completion(struct tevent_req *req)
6458 {
6459         uint16_t fnum;
6460         NTSTATUS status;
6461         status = cli_open_recv(req, &fnum);
6462         TALLOC_FREE(req);
6463
6464         d_printf("cli_open_recv returned %s: %d\n",
6465                  nt_errstr(status),
6466                  NT_STATUS_IS_OK(status) ? fnum : -1);
6467 }
6468
6469 static void chain1_write_completion(struct tevent_req *req)
6470 {
6471         size_t written;
6472         NTSTATUS status;
6473         status = cli_write_andx_recv(req, &written);
6474         TALLOC_FREE(req);
6475
6476         d_printf("cli_write_andx_recv returned %s: %d\n",
6477                  nt_errstr(status),
6478                  NT_STATUS_IS_OK(status) ? (int)written : -1);
6479 }
6480
6481 static void chain1_close_completion(struct tevent_req *req)
6482 {
6483         NTSTATUS status;
6484         bool *done = (bool *)tevent_req_callback_data_void(req);
6485
6486         status = cli_close_recv(req);
6487         *done = true;
6488
6489         TALLOC_FREE(req);
6490
6491         d_printf("cli_close returned %s\n", nt_errstr(status));
6492 }
6493
6494 static bool run_chain1(int dummy)
6495 {
6496         struct cli_state *cli1;
6497         struct event_context *evt = event_context_init(NULL);
6498         struct tevent_req *reqs[3], *smbreqs[3];
6499         bool done = false;
6500         const char *str = "foobar";
6501         NTSTATUS status;
6502
6503         printf("starting chain1 test\n");
6504         if (!torture_open_connection(&cli1, 0)) {
6505                 return False;
6506         }
6507
6508         cli_sockopt(cli1, sockops);
6509
6510         reqs[0] = cli_open_create(talloc_tos(), evt, cli1, "\\test",
6511                                   O_CREAT|O_RDWR, 0, &smbreqs[0]);
6512         if (reqs[0] == NULL) return false;
6513         tevent_req_set_callback(reqs[0], chain1_open_completion, NULL);
6514
6515
6516         reqs[1] = cli_write_andx_create(talloc_tos(), evt, cli1, 0, 0,
6517                                         (const uint8_t *)str, 0, strlen(str)+1,
6518                                         smbreqs, 1, &smbreqs[1]);
6519         if (reqs[1] == NULL) return false;
6520         tevent_req_set_callback(reqs[1], chain1_write_completion, NULL);
6521
6522         reqs[2] = cli_close_create(talloc_tos(), evt, cli1, 0, &smbreqs[2]);
6523         if (reqs[2] == NULL) return false;
6524         tevent_req_set_callback(reqs[2], chain1_close_completion, &done);
6525
6526         status = cli_smb_chain_send(smbreqs, ARRAY_SIZE(smbreqs));
6527         if (!NT_STATUS_IS_OK(status)) {
6528                 return false;
6529         }
6530
6531         while (!done) {
6532                 tevent_loop_once(evt);
6533         }
6534
6535         torture_close_connection(cli1);
6536         return True;
6537 }
6538
6539 static void chain2_sesssetup_completion(struct tevent_req *req)
6540 {
6541         NTSTATUS status;
6542         status = cli_session_setup_guest_recv(req);
6543         d_printf("sesssetup returned %s\n", nt_errstr(status));
6544 }
6545
6546 static void chain2_tcon_completion(struct tevent_req *req)
6547 {
6548         bool *done = (bool *)tevent_req_callback_data_void(req);
6549         NTSTATUS status;
6550         status = cli_tcon_andx_recv(req);
6551         d_printf("tcon_and_x returned %s\n", nt_errstr(status));
6552         *done = true;
6553 }
6554
6555 static bool run_chain2(int dummy)
6556 {
6557         struct cli_state *cli1;
6558         struct event_context *evt = event_context_init(NULL);
6559         struct tevent_req *reqs[2], *smbreqs[2];
6560         bool done = false;
6561         NTSTATUS status;
6562
6563         printf("starting chain2 test\n");
6564         status = cli_start_connection(&cli1, lp_netbios_name(), host, NULL,
6565                                       port_to_use, Undefined, 0);
6566         if (!NT_STATUS_IS_OK(status)) {
6567                 return False;
6568         }
6569
6570         cli_sockopt(cli1, sockops);
6571
6572         reqs[0] = cli_session_setup_guest_create(talloc_tos(), evt, cli1,
6573                                                  &smbreqs[0]);
6574         if (reqs[0] == NULL) return false;
6575         tevent_req_set_callback(reqs[0], chain2_sesssetup_completion, NULL);
6576
6577         reqs[1] = cli_tcon_andx_create(talloc_tos(), evt, cli1, "IPC$",
6578                                        "?????", NULL, 0, &smbreqs[1]);
6579         if (reqs[1] == NULL) return false;
6580         tevent_req_set_callback(reqs[1], chain2_tcon_completion, &done);
6581
6582         status = cli_smb_chain_send(smbreqs, ARRAY_SIZE(smbreqs));
6583         if (!NT_STATUS_IS_OK(status)) {
6584                 return false;
6585         }
6586
6587         while (!done) {
6588                 tevent_loop_once(evt);
6589         }
6590
6591         torture_close_connection(cli1);
6592         return True;
6593 }
6594
6595
6596 struct torture_createdel_state {
6597         struct tevent_context *ev;
6598         struct cli_state *cli;
6599 };
6600
6601 static void torture_createdel_created(struct tevent_req *subreq);
6602 static void torture_createdel_closed(struct tevent_req *subreq);
6603
6604 static struct tevent_req *torture_createdel_send(TALLOC_CTX *mem_ctx,
6605                                                  struct tevent_context *ev,
6606                                                  struct cli_state *cli,
6607                                                  const char *name)
6608 {
6609         struct tevent_req *req, *subreq;
6610         struct torture_createdel_state *state;
6611
6612         req = tevent_req_create(mem_ctx, &state,
6613                                 struct torture_createdel_state);
6614         if (req == NULL) {
6615                 return NULL;
6616         }
6617         state->ev = ev;
6618         state->cli = cli;
6619
6620         subreq = cli_ntcreate_send(
6621                 state, ev, cli, name, 0,
6622                 FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
6623                 FILE_ATTRIBUTE_NORMAL,
6624                 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
6625                 FILE_OPEN_IF, FILE_DELETE_ON_CLOSE, 0);
6626
6627         if (tevent_req_nomem(subreq, req)) {
6628                 return tevent_req_post(req, ev);
6629         }
6630         tevent_req_set_callback(subreq, torture_createdel_created, req);
6631         return req;
6632 }
6633
6634 static void torture_createdel_created(struct tevent_req *subreq)
6635 {
6636         struct tevent_req *req = tevent_req_callback_data(
6637                 subreq, struct tevent_req);
6638         struct torture_createdel_state *state = tevent_req_data(
6639                 req, struct torture_createdel_state);
6640         NTSTATUS status;
6641         uint16_t fnum;
6642
6643         status = cli_ntcreate_recv(subreq, &fnum);
6644         TALLOC_FREE(subreq);
6645         if (!NT_STATUS_IS_OK(status)) {
6646                 DEBUG(10, ("cli_ntcreate_recv returned %s\n",
6647                            nt_errstr(status)));
6648                 tevent_req_nterror(req, status);
6649                 return;
6650         }
6651
6652         subreq = cli_close_send(state, state->ev, state->cli, fnum);
6653         if (tevent_req_nomem(subreq, req)) {
6654                 return;
6655         }
6656         tevent_req_set_callback(subreq, torture_createdel_closed, req);
6657 }
6658
6659 static void torture_createdel_closed(struct tevent_req *subreq)
6660 {
6661         struct tevent_req *req = tevent_req_callback_data(
6662                 subreq, struct tevent_req);
6663         NTSTATUS status;
6664
6665         status = cli_close_recv(subreq);
6666         if (!NT_STATUS_IS_OK(status)) {
6667                 DEBUG(10, ("cli_close_recv returned %s\n", nt_errstr(status)));
6668                 tevent_req_nterror(req, status);
6669                 return;
6670         }
6671         tevent_req_done(req);
6672 }
6673
6674 static NTSTATUS torture_createdel_recv(struct tevent_req *req)
6675 {
6676         return tevent_req_simple_recv_ntstatus(req);
6677 }
6678
6679 struct torture_createdels_state {
6680         struct tevent_context *ev;
6681         struct cli_state *cli;
6682         const char *base_name;
6683         int sent;
6684         int received;
6685         int num_files;
6686         struct tevent_req **reqs;
6687 };
6688
6689 static void torture_createdels_done(struct tevent_req *subreq);
6690
6691 static struct tevent_req *torture_createdels_send(TALLOC_CTX *mem_ctx,
6692                                                   struct tevent_context *ev,
6693                                                   struct cli_state *cli,
6694                                                   const char *base_name,
6695                                                   int num_parallel,
6696                                                   int num_files)
6697 {
6698         struct tevent_req *req;
6699         struct torture_createdels_state *state;
6700         int i;
6701
6702         req = tevent_req_create(mem_ctx, &state,
6703                                 struct torture_createdels_state);
6704         if (req == NULL) {
6705                 return NULL;
6706         }
6707         state->ev = ev;
6708         state->cli = cli;
6709         state->base_name = talloc_strdup(state, base_name);
6710         if (tevent_req_nomem(state->base_name, req)) {
6711                 return tevent_req_post(req, ev);
6712         }
6713         state->num_files = MAX(num_parallel, num_files);
6714         state->sent = 0;
6715         state->received = 0;
6716
6717         state->reqs = talloc_array(state, struct tevent_req *, num_parallel);
6718         if (tevent_req_nomem(state->reqs, req)) {
6719                 return tevent_req_post(req, ev);
6720         }
6721
6722         for (i=0; i<num_parallel; i++) {
6723                 char *name;
6724
6725                 name = talloc_asprintf(state, "%s%8.8d", state->base_name,
6726                                        state->sent);
6727                 if (tevent_req_nomem(name, req)) {
6728                         return tevent_req_post(req, ev);
6729                 }
6730                 state->reqs[i] = torture_createdel_send(
6731                         state->reqs, state->ev, state->cli, name);
6732                 if (tevent_req_nomem(state->reqs[i], req)) {
6733                         return tevent_req_post(req, ev);
6734                 }
6735                 name = talloc_move(state->reqs[i], &name);
6736                 tevent_req_set_callback(state->reqs[i],
6737                                         torture_createdels_done, req);
6738                 state->sent += 1;
6739         }
6740         return req;
6741 }
6742
6743 static void torture_createdels_done(struct tevent_req *subreq)
6744 {
6745         struct tevent_req *req = tevent_req_callback_data(
6746                 subreq, struct tevent_req);
6747         struct torture_createdels_state *state = tevent_req_data(
6748                 req, struct torture_createdels_state);
6749         size_t num_parallel = talloc_array_length(state->reqs);
6750         NTSTATUS status;
6751         char *name;
6752         int i;
6753
6754         status = torture_createdel_recv(subreq);
6755         if (!NT_STATUS_IS_OK(status)){
6756                 DEBUG(10, ("torture_createdel_recv returned %s\n",
6757                            nt_errstr(status)));
6758                 TALLOC_FREE(subreq);
6759                 tevent_req_nterror(req, status);
6760                 return;
6761         }
6762
6763         for (i=0; i<num_parallel; i++) {
6764                 if (subreq == state->reqs[i]) {
6765                         break;
6766                 }
6767         }
6768         if (i == num_parallel) {
6769                 DEBUG(10, ("received something we did not send\n"));
6770                 tevent_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
6771                 return;
6772         }
6773         TALLOC_FREE(state->reqs[i]);
6774
6775         if (state->sent >= state->num_files) {
6776                 tevent_req_done(req);
6777                 return;
6778         }
6779
6780         name = talloc_asprintf(state, "%s%8.8d", state->base_name,
6781                                state->sent);
6782         if (tevent_req_nomem(name, req)) {
6783                 return;
6784         }
6785         state->reqs[i] = torture_createdel_send(state->reqs, state->ev,
6786                                                 state->cli, name);
6787         if (tevent_req_nomem(state->reqs[i], req)) {
6788                 return;
6789         }
6790         name = talloc_move(state->reqs[i], &name);
6791         tevent_req_set_callback(state->reqs[i], torture_createdels_done, req);
6792         state->sent += 1;
6793 }
6794
6795 static NTSTATUS torture_createdels_recv(struct tevent_req *req)
6796 {
6797         return tevent_req_simple_recv_ntstatus(req);
6798 }
6799
6800 struct swallow_notify_state {
6801         struct tevent_context *ev;
6802         struct cli_state *cli;
6803         uint16_t fnum;
6804         uint32_t completion_filter;
6805         bool recursive;
6806         bool (*fn)(uint32_t action, const char *name, void *priv);
6807         void *priv;
6808 };
6809
6810 static void swallow_notify_done(struct tevent_req *subreq);
6811
6812 static struct tevent_req *swallow_notify_send(TALLOC_CTX *mem_ctx,
6813                                               struct tevent_context *ev,
6814                                               struct cli_state *cli,
6815                                               uint16_t fnum,
6816                                               uint32_t completion_filter,
6817                                               bool recursive,
6818                                               bool (*fn)(uint32_t action,
6819                                                          const char *name,
6820                                                          void *priv),
6821                                               void *priv)
6822 {
6823         struct tevent_req *req, *subreq;
6824         struct swallow_notify_state *state;
6825
6826         req = tevent_req_create(mem_ctx, &state,
6827                                 struct swallow_notify_state);
6828         if (req == NULL) {
6829                 return NULL;
6830         }
6831         state->ev = ev;
6832         state->cli = cli;
6833         state->fnum = fnum;
6834         state->completion_filter = completion_filter;
6835         state->recursive = recursive;
6836         state->fn = fn;
6837         state->priv = priv;
6838
6839         subreq = cli_notify_send(state, state->ev, state->cli, state->fnum,
6840                                  0xffff, state->completion_filter,
6841                                  state->recursive);
6842         if (tevent_req_nomem(subreq, req)) {
6843                 return tevent_req_post(req, ev);
6844         }
6845         tevent_req_set_callback(subreq, swallow_notify_done, req);
6846         return req;
6847 }
6848
6849 static void swallow_notify_done(struct tevent_req *subreq)
6850 {
6851         struct tevent_req *req = tevent_req_callback_data(
6852                 subreq, struct tevent_req);
6853         struct swallow_notify_state *state = tevent_req_data(
6854                 req, struct swallow_notify_state);
6855         NTSTATUS status;
6856         uint32_t i, num_changes;
6857         struct notify_change *changes;
6858
6859         status = cli_notify_recv(subreq, state, &num_changes, &changes);
6860         TALLOC_FREE(subreq);
6861         if (!NT_STATUS_IS_OK(status)) {
6862                 DEBUG(10, ("cli_notify_recv returned %s\n",
6863                            nt_errstr(status)));
6864                 tevent_req_nterror(req, status);
6865                 return;
6866         }
6867
6868         for (i=0; i<num_changes; i++) {
6869                 state->fn(changes[i].action, changes[i].name, state->priv);
6870         }
6871         TALLOC_FREE(changes);
6872
6873         subreq = cli_notify_send(state, state->ev, state->cli, state->fnum,
6874                                  0xffff, state->completion_filter,
6875                                  state->recursive);
6876         if (tevent_req_nomem(subreq, req)) {
6877                 return;
6878         }
6879         tevent_req_set_callback(subreq, swallow_notify_done, req);
6880 }
6881
6882 static bool print_notifies(uint32_t action, const char *name, void *priv)
6883 {
6884         if (DEBUGLEVEL > 5) {
6885                 d_printf("%d %s\n", (int)action, name);
6886         }
6887         return true;
6888 }
6889
6890 static void notify_bench_done(struct tevent_req *req)
6891 {
6892         int *num_finished = (int *)tevent_req_callback_data_void(req);
6893         *num_finished += 1;
6894 }
6895
6896 static bool run_notify_bench(int dummy)
6897 {
6898         const char *dname = "\\notify-bench";
6899         struct tevent_context *ev;
6900         NTSTATUS status;
6901         uint16_t dnum;
6902         struct tevent_req *req1;
6903         struct tevent_req *req2 = NULL;
6904         int i, num_unc_names;
6905         int num_finished = 0;
6906
6907         printf("starting notify-bench test\n");
6908
6909         if (use_multishare_conn) {
6910                 char **unc_list;
6911                 unc_list = file_lines_load(multishare_conn_fname,
6912                                            &num_unc_names, 0, NULL);
6913                 if (!unc_list || num_unc_names <= 0) {
6914                         d_printf("Failed to load unc names list from '%s'\n",
6915                                  multishare_conn_fname);
6916                         return false;
6917                 }
6918                 TALLOC_FREE(unc_list);
6919         } else {
6920                 num_unc_names = 1;
6921         }
6922
6923         ev = tevent_context_init(talloc_tos());
6924         if (ev == NULL) {
6925                 d_printf("tevent_context_init failed\n");
6926                 return false;
6927         }
6928
6929         for (i=0; i<num_unc_names; i++) {
6930                 struct cli_state *cli;
6931                 char *base_fname;
6932
6933                 base_fname = talloc_asprintf(talloc_tos(), "%s\\file%3.3d.",
6934                                              dname, i);
6935                 if (base_fname == NULL) {
6936                         return false;
6937                 }
6938
6939                 if (!torture_open_connection(&cli, i)) {
6940                         return false;
6941                 }
6942
6943                 status = cli_ntcreate(cli, dname, 0,
6944                                       MAXIMUM_ALLOWED_ACCESS,
6945                                       0, FILE_SHARE_READ|FILE_SHARE_WRITE|
6946                                       FILE_SHARE_DELETE,
6947                                       FILE_OPEN_IF, FILE_DIRECTORY_FILE, 0,
6948                                       &dnum);
6949
6950                 if (!NT_STATUS_IS_OK(status)) {
6951                         d_printf("Could not create %s: %s\n", dname,
6952                                  nt_errstr(status));
6953                         return false;
6954                 }
6955
6956                 req1 = swallow_notify_send(talloc_tos(), ev, cli, dnum,
6957                                            FILE_NOTIFY_CHANGE_FILE_NAME |
6958                                            FILE_NOTIFY_CHANGE_DIR_NAME |
6959                                            FILE_NOTIFY_CHANGE_ATTRIBUTES |
6960                                            FILE_NOTIFY_CHANGE_LAST_WRITE,
6961                                            false, print_notifies, NULL);
6962                 if (req1 == NULL) {
6963                         d_printf("Could not create notify request\n");
6964                         return false;
6965                 }
6966
6967                 req2 = torture_createdels_send(talloc_tos(), ev, cli,
6968                                                base_fname, 10, torture_numops);
6969                 if (req2 == NULL) {
6970                         d_printf("Could not create createdels request\n");
6971                         return false;
6972                 }
6973                 TALLOC_FREE(base_fname);
6974
6975                 tevent_req_set_callback(req2, notify_bench_done,
6976                                         &num_finished);
6977         }
6978
6979         while (num_finished < num_unc_names) {
6980                 int ret;
6981                 ret = tevent_loop_once(ev);
6982                 if (ret != 0) {
6983                         d_printf("tevent_loop_once failed\n");
6984                         return false;
6985                 }
6986         }
6987
6988         if (!tevent_req_poll(req2, ev)) {
6989                 d_printf("tevent_req_poll failed\n");
6990         }
6991
6992         status = torture_createdels_recv(req2);
6993         d_printf("torture_createdels_recv returned %s\n", nt_errstr(status));
6994
6995         return true;
6996 }
6997
6998 static bool run_mangle1(int dummy)
6999 {
7000         struct cli_state *cli;
7001         const char *fname = "this_is_a_long_fname_to_be_mangled.txt";
7002         uint16_t fnum;
7003         fstring alt_name;
7004         NTSTATUS status;
7005         time_t change_time, access_time, write_time;
7006         SMB_OFF_T size;
7007         uint16_t mode;
7008
7009         printf("starting mangle1 test\n");
7010         if (!torture_open_connection(&cli, 0)) {
7011                 return False;
7012         }
7013
7014         cli_sockopt(cli, sockops);
7015
7016         status = cli_ntcreate(cli, fname, 0, GENERIC_ALL_ACCESS|DELETE_ACCESS,
7017                               FILE_ATTRIBUTE_NORMAL, 0, FILE_OVERWRITE_IF,
7018                               0, 0, &fnum);
7019         if (!NT_STATUS_IS_OK(status)) {
7020                 d_printf("open %s failed: %s\n", fname, nt_errstr(status));
7021                 return false;
7022         }
7023         cli_close(cli, fnum);
7024
7025         status = cli_qpathinfo_alt_name(cli, fname, alt_name);
7026         if (!NT_STATUS_IS_OK(status)) {
7027                 d_printf("cli_qpathinfo_alt_name failed: %s\n",
7028                          nt_errstr(status));
7029                 return false;
7030         }
7031         d_printf("alt_name: %s\n", alt_name);
7032
7033         status = cli_open(cli, alt_name, O_RDONLY, DENY_NONE, &fnum);
7034         if (!NT_STATUS_IS_OK(status)) {
7035                 d_printf("cli_open(%s) failed: %s\n", alt_name,
7036                          nt_errstr(status));
7037                 return false;
7038         }
7039         cli_close(cli, fnum);
7040
7041         status = cli_qpathinfo1(cli, alt_name, &change_time, &access_time,
7042                                 &write_time, &size, &mode);
7043         if (!NT_STATUS_IS_OK(status)) {
7044                 d_printf("cli_qpathinfo1(%s) failed: %s\n", alt_name,
7045                          nt_errstr(status));
7046                 return false;
7047         }
7048
7049         return true;
7050 }
7051
7052 static size_t null_source(uint8_t *buf, size_t n, void *priv)
7053 {
7054         size_t *to_pull = (size_t *)priv;
7055         size_t thistime = *to_pull;
7056
7057         thistime = MIN(thistime, n);
7058         if (thistime == 0) {
7059                 return 0;
7060         }
7061
7062         memset(buf, 0, thistime);
7063         *to_pull -= thistime;
7064         return thistime;
7065 }
7066
7067 static bool run_windows_write(int dummy)
7068 {
7069         struct cli_state *cli1;
7070         uint16_t fnum;
7071         int i;
7072         bool ret = false;
7073         const char *fname = "\\writetest.txt";
7074         struct timeval start_time;
7075         double seconds;
7076         double kbytes;
7077         NTSTATUS status;
7078
7079         printf("starting windows_write test\n");
7080         if (!torture_open_connection(&cli1, 0)) {
7081                 return False;
7082         }
7083
7084         status = cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum);
7085         if (!NT_STATUS_IS_OK(status)) {
7086                 printf("open failed (%s)\n", nt_errstr(status));
7087                 return False;
7088         }
7089
7090         cli_sockopt(cli1, sockops);
7091
7092         start_time = timeval_current();
7093
7094         for (i=0; i<torture_numops; i++) {
7095                 uint8_t c = 0;
7096                 off_t start = i * torture_blocksize;
7097                 size_t to_pull = torture_blocksize - 1;
7098
7099                 status = cli_writeall(cli1, fnum, 0, &c,
7100                                       start + torture_blocksize - 1, 1, NULL);
7101                 if (!NT_STATUS_IS_OK(status)) {
7102                         printf("cli_write failed: %s\n", nt_errstr(status));
7103                         goto fail;
7104                 }
7105
7106                 status = cli_push(cli1, fnum, 0, i * torture_blocksize, torture_blocksize,
7107                                   null_source, &to_pull);
7108                 if (!NT_STATUS_IS_OK(status)) {
7109                         printf("cli_push returned: %s\n", nt_errstr(status));
7110                         goto fail;
7111                 }
7112         }
7113
7114         seconds = timeval_elapsed(&start_time);
7115         kbytes = (double)torture_blocksize * torture_numops;
7116         kbytes /= 1024;
7117
7118         printf("Wrote %d kbytes in %.2f seconds: %d kb/sec\n", (int)kbytes,
7119                (double)seconds, (int)(kbytes/seconds));
7120
7121         ret = true;
7122  fail:
7123         cli_close(cli1, fnum);
7124         cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
7125         torture_close_connection(cli1);
7126         return ret;
7127 }
7128
7129 static bool run_cli_echo(int dummy)
7130 {
7131         struct cli_state *cli;
7132         NTSTATUS status;
7133
7134         printf("starting cli_echo test\n");
7135         if (!torture_open_connection(&cli, 0)) {
7136                 return false;
7137         }
7138         cli_sockopt(cli, sockops);
7139
7140         status = cli_echo(cli, 5, data_blob_const("hello", 5));
7141
7142         d_printf("cli_echo returned %s\n", nt_errstr(status));
7143
7144         torture_close_connection(cli);
7145         return NT_STATUS_IS_OK(status);
7146 }
7147
7148 static bool run_uid_regression_test(int dummy)
7149 {
7150         static struct cli_state *cli;
7151         int16_t old_vuid;
7152         int16_t old_cnum;
7153         bool correct = True;
7154         NTSTATUS status;
7155
7156         printf("starting uid regression test\n");
7157
7158         if (!torture_open_connection(&cli, 0)) {
7159                 return False;
7160         }
7161
7162         cli_sockopt(cli, sockops);
7163
7164         /* Ok - now save then logoff our current user. */
7165         old_vuid = cli_state_get_uid(cli);
7166
7167         status = cli_ulogoff(cli);
7168         if (!NT_STATUS_IS_OK(status)) {
7169                 d_printf("(%s) cli_ulogoff failed: %s\n",
7170                          __location__, nt_errstr(status));
7171                 correct = false;
7172                 goto out;
7173         }
7174
7175         cli_state_set_uid(cli, old_vuid);
7176
7177         /* Try an operation. */
7178         status = cli_mkdir(cli, "\\uid_reg_test");
7179         if (NT_STATUS_IS_OK(status)) {
7180                 d_printf("(%s) cli_mkdir succeeded\n",
7181                          __location__);
7182                 correct = false;
7183                 goto out;
7184         } else {
7185                 /* Should be bad uid. */
7186                 if (!check_error(__LINE__, status, ERRSRV, ERRbaduid,
7187                                  NT_STATUS_USER_SESSION_DELETED)) {
7188                         correct = false;
7189                         goto out;
7190                 }
7191         }
7192
7193         old_cnum = cli_state_get_tid(cli);
7194
7195         /* Now try a SMBtdis with the invald vuid set to zero. */
7196         cli_state_set_uid(cli, 0);
7197
7198         /* This should succeed. */
7199         status = cli_tdis(cli);
7200
7201         if (NT_STATUS_IS_OK(status)) {
7202                 d_printf("First tdis with invalid vuid should succeed.\n");
7203         } else {
7204                 d_printf("First tdis failed (%s)\n", nt_errstr(status));
7205                 correct = false;
7206                 goto out;
7207         }
7208
7209         cli_state_set_uid(cli, old_vuid);
7210         cli_state_set_tid(cli, old_cnum);
7211
7212         /* This should fail. */
7213         status = cli_tdis(cli);
7214         if (NT_STATUS_IS_OK(status)) {
7215                 d_printf("Second tdis with invalid vuid should fail - succeeded instead !.\n");
7216                 correct = false;
7217                 goto out;
7218         } else {
7219                 /* Should be bad tid. */
7220                 if (!check_error(__LINE__, status, ERRSRV, ERRinvnid,
7221                                 NT_STATUS_NETWORK_NAME_DELETED)) {
7222                         correct = false;
7223                         goto out;
7224                 }
7225         }
7226
7227         cli_rmdir(cli, "\\uid_reg_test");
7228
7229   out:
7230
7231         cli_shutdown(cli);
7232         return correct;
7233 }
7234
7235
7236 static const char *illegal_chars = "*\\/?<>|\":";
7237 static char force_shortname_chars[] = " +,.[];=\177";
7238
7239 static NTSTATUS shortname_del_fn(const char *mnt, struct file_info *finfo,
7240                              const char *mask, void *state)
7241 {
7242         struct cli_state *pcli = (struct cli_state *)state;
7243         fstring fname;
7244         NTSTATUS status = NT_STATUS_OK;
7245
7246         slprintf(fname, sizeof(fname), "\\shortname\\%s", finfo->name);
7247
7248         if (strcmp(finfo->name, ".") == 0 || strcmp(finfo->name, "..") == 0)
7249                 return NT_STATUS_OK;
7250
7251         if (finfo->mode & FILE_ATTRIBUTE_DIRECTORY) {
7252                 status = cli_rmdir(pcli, fname);
7253                 if (!NT_STATUS_IS_OK(status)) {
7254                         printf("del_fn: failed to rmdir %s\n,", fname );
7255                 }
7256         } else {
7257                 status = cli_unlink(pcli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
7258                 if (!NT_STATUS_IS_OK(status)) {
7259                         printf("del_fn: failed to unlink %s\n,", fname );
7260                 }
7261         }
7262         return status;
7263 }
7264
7265 struct sn_state {
7266         int matched;
7267         int i;
7268         bool val;
7269 };
7270
7271 static NTSTATUS shortname_list_fn(const char *mnt, struct file_info *finfo,
7272                               const char *name, void *state)
7273 {
7274         struct sn_state *s = (struct sn_state  *)state;
7275         int i = s->i;
7276
7277 #if 0
7278         printf("shortname list: i = %d, name = |%s|, shortname = |%s|\n",
7279                 i, finfo->name, finfo->short_name);
7280 #endif
7281
7282         if (strchr(force_shortname_chars, i)) {
7283                 if (!finfo->short_name) {
7284                         /* Shortname not created when it should be. */
7285                         d_printf("(%s) ERROR: Shortname was not created for file %s containing %d\n",
7286                                 __location__, finfo->name, i);
7287                         s->val = true;
7288                 }
7289         } else if (finfo->short_name){
7290                 /* Shortname created when it should not be. */
7291                 d_printf("(%s) ERROR: Shortname %s was created for file %s\n",
7292                         __location__, finfo->short_name, finfo->name);
7293                 s->val = true;
7294         }
7295         s->matched += 1;
7296         return NT_STATUS_OK;
7297 }
7298
7299 static bool run_shortname_test(int dummy)
7300 {
7301         static struct cli_state *cli;
7302         bool correct = True;
7303         int i;
7304         struct sn_state s;
7305         char fname[20];
7306         NTSTATUS status;
7307
7308         printf("starting shortname test\n");
7309
7310         if (!torture_open_connection(&cli, 0)) {
7311                 return False;
7312         }
7313
7314         cli_sockopt(cli, sockops);
7315
7316         cli_list(cli, "\\shortname\\*", 0, shortname_del_fn, cli);
7317         cli_list(cli, "\\shortname\\*", FILE_ATTRIBUTE_DIRECTORY, shortname_del_fn, cli);
7318         cli_rmdir(cli, "\\shortname");
7319
7320         status = cli_mkdir(cli, "\\shortname");
7321         if (!NT_STATUS_IS_OK(status)) {
7322                 d_printf("(%s) cli_mkdir of \\shortname failed: %s\n",
7323                         __location__, nt_errstr(status));
7324                 correct = false;
7325                 goto out;
7326         }
7327
7328         strlcpy(fname, "\\shortname\\", sizeof(fname));
7329         strlcat(fname, "test .txt", sizeof(fname));
7330
7331         s.val = false;
7332
7333         for (i = 32; i < 128; i++) {
7334                 uint16_t fnum = (uint16_t)-1;
7335
7336                 s.i = i;
7337
7338                 if (strchr(illegal_chars, i)) {
7339                         continue;
7340                 }
7341                 fname[15] = i;
7342
7343                 status = cli_ntcreate(cli, fname, 0, GENERIC_ALL_ACCESS, FILE_ATTRIBUTE_NORMAL,
7344                                    FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OVERWRITE_IF, 0, 0, &fnum);
7345                 if (!NT_STATUS_IS_OK(status)) {
7346                         d_printf("(%s) cli_nt_create of %s failed: %s\n",
7347                                 __location__, fname, nt_errstr(status));
7348                         correct = false;
7349                         goto out;
7350                 }
7351                 cli_close(cli, fnum);
7352
7353                 s.matched = 0;
7354                 status = cli_list(cli, "\\shortname\\test*.*", 0,
7355                                   shortname_list_fn, &s);
7356                 if (s.matched != 1) {
7357                         d_printf("(%s) failed to list %s: %s\n",
7358                                 __location__, fname, nt_errstr(status));
7359                         correct = false;
7360                         goto out;
7361                 }
7362
7363                 status = cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
7364                 if (!NT_STATUS_IS_OK(status)) {
7365                         d_printf("(%s) failed to delete %s: %s\n",
7366                                 __location__, fname, nt_errstr(status));
7367                         correct = false;
7368                         goto out;
7369                 }
7370
7371                 if (s.val) {
7372                         correct = false;
7373                         goto out;
7374                 }
7375         }
7376
7377   out:
7378
7379         cli_list(cli, "\\shortname\\*", 0, shortname_del_fn, cli);
7380         cli_list(cli, "\\shortname\\*", FILE_ATTRIBUTE_DIRECTORY, shortname_del_fn, cli);
7381         cli_rmdir(cli, "\\shortname");
7382         torture_close_connection(cli);
7383         return correct;
7384 }
7385
7386 static void pagedsearch_cb(struct tevent_req *req)
7387 {
7388         int rc;
7389         struct tldap_message *msg;
7390         char *dn;
7391
7392         rc = tldap_search_paged_recv(req, talloc_tos(), &msg);
7393         if (rc != TLDAP_SUCCESS) {
7394                 d_printf("tldap_search_paged_recv failed: %s\n",
7395                          tldap_err2string(rc));
7396                 return;
7397         }
7398         if (tldap_msg_type(msg) != TLDAP_RES_SEARCH_ENTRY) {
7399                 TALLOC_FREE(msg);
7400                 return;
7401         }
7402         if (!tldap_entry_dn(msg, &dn)) {
7403                 d_printf("tldap_entry_dn failed\n");
7404                 return;
7405         }
7406         d_printf("%s\n", dn);
7407         TALLOC_FREE(msg);
7408 }
7409
7410 static bool run_tldap(int dummy)
7411 {
7412         struct tldap_context *ld;
7413         int fd, rc;
7414         NTSTATUS status;
7415         struct sockaddr_storage addr;
7416         struct tevent_context *ev;
7417         struct tevent_req *req;
7418         char *basedn;
7419         const char *filter;
7420
7421         if (!resolve_name(host, &addr, 0, false)) {
7422                 d_printf("could not find host %s\n", host);
7423                 return false;
7424         }
7425         status = open_socket_out(&addr, 389, 9999, &fd);
7426         if (!NT_STATUS_IS_OK(status)) {
7427                 d_printf("open_socket_out failed: %s\n", nt_errstr(status));
7428                 return false;
7429         }
7430
7431         ld = tldap_context_create(talloc_tos(), fd);
7432         if (ld == NULL) {
7433                 close(fd);
7434                 d_printf("tldap_context_create failed\n");
7435                 return false;
7436         }
7437
7438         rc = tldap_fetch_rootdse(ld);
7439         if (rc != TLDAP_SUCCESS) {
7440                 d_printf("tldap_fetch_rootdse failed: %s\n",
7441                          tldap_errstr(talloc_tos(), ld, rc));
7442                 return false;
7443         }
7444
7445         basedn = tldap_talloc_single_attribute(
7446                 tldap_rootdse(ld), "defaultNamingContext", talloc_tos());
7447         if (basedn == NULL) {
7448                 d_printf("no defaultNamingContext\n");
7449                 return false;
7450         }
7451         d_printf("defaultNamingContext: %s\n", basedn);
7452
7453         ev = tevent_context_init(talloc_tos());
7454         if (ev == NULL) {
7455                 d_printf("tevent_context_init failed\n");
7456                 return false;
7457         }
7458
7459         req = tldap_search_paged_send(talloc_tos(), ev, ld, basedn,
7460                                       TLDAP_SCOPE_SUB, "(objectclass=*)",
7461                                       NULL, 0, 0,
7462                                       NULL, 0, NULL, 0, 0, 0, 0, 5);
7463         if (req == NULL) {
7464                 d_printf("tldap_search_paged_send failed\n");
7465                 return false;
7466         }
7467         tevent_req_set_callback(req, pagedsearch_cb, NULL);
7468
7469         tevent_req_poll(req, ev);
7470
7471         TALLOC_FREE(req);
7472
7473         /* test search filters against rootDSE */
7474         filter = "(&(|(name=samba)(nextRid<=10000000)(usnChanged>=10)(samba~=ambas)(!(name=s*m*a)))"
7475                    "(|(name:=samba)(name:dn:2.5.13.5:=samba)(:dn:2.5.13.5:=samba)(!(name=*samba))))";
7476
7477         rc = tldap_search(ld, "", TLDAP_SCOPE_BASE, filter,
7478                           NULL, 0, 0, NULL, 0, NULL, 0, 0, 0, 0,
7479                           talloc_tos(), NULL, NULL);
7480         if (rc != TLDAP_SUCCESS) {
7481                 d_printf("tldap_search with complex filter failed: %s\n",
7482                          tldap_errstr(talloc_tos(), ld, rc));
7483                 return false;
7484         }
7485
7486         TALLOC_FREE(ld);
7487         return true;
7488 }
7489
7490 /* Torture test to ensure no regression of :
7491 https://bugzilla.samba.org/show_bug.cgi?id=7084
7492 */
7493
7494 static bool run_dir_createtime(int dummy)
7495 {
7496         struct cli_state *cli;
7497         const char *dname = "\\testdir";
7498         const char *fname = "\\testdir\\testfile";
7499         NTSTATUS status;
7500         struct timespec create_time;
7501         struct timespec create_time1;
7502         uint16_t fnum;
7503         bool ret = false;
7504
7505         if (!torture_open_connection(&cli, 0)) {
7506                 return false;
7507         }
7508
7509         cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
7510         cli_rmdir(cli, dname);
7511
7512         status = cli_mkdir(cli, dname);
7513         if (!NT_STATUS_IS_OK(status)) {
7514                 printf("mkdir failed: %s\n", nt_errstr(status));
7515                 goto out;
7516         }
7517
7518         status = cli_qpathinfo2(cli, dname, &create_time, NULL, NULL, NULL,
7519                                 NULL, NULL, NULL);
7520         if (!NT_STATUS_IS_OK(status)) {
7521                 printf("cli_qpathinfo2 returned %s\n",
7522                        nt_errstr(status));
7523                 goto out;
7524         }
7525
7526         /* Sleep 3 seconds, then create a file. */
7527         sleep(3);
7528
7529         status = cli_open(cli, fname, O_RDWR | O_CREAT | O_EXCL,
7530                          DENY_NONE, &fnum);
7531         if (!NT_STATUS_IS_OK(status)) {
7532                 printf("cli_open failed: %s\n", nt_errstr(status));
7533                 goto out;
7534         }
7535
7536         status = cli_qpathinfo2(cli, dname, &create_time1, NULL, NULL, NULL,
7537                                 NULL, NULL, NULL);
7538         if (!NT_STATUS_IS_OK(status)) {
7539                 printf("cli_qpathinfo2 (2) returned %s\n",
7540                        nt_errstr(status));
7541                 goto out;
7542         }
7543
7544         if (timespec_compare(&create_time1, &create_time)) {
7545                 printf("run_dir_createtime: create time was updated (error)\n");
7546         } else {
7547                 printf("run_dir_createtime: create time was not updated (correct)\n");
7548                 ret = true;
7549         }
7550
7551   out:
7552
7553         cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
7554         cli_rmdir(cli, dname);
7555         if (!torture_close_connection(cli)) {
7556                 ret = false;
7557         }
7558         return ret;
7559 }
7560
7561
7562 static bool run_streamerror(int dummy)
7563 {
7564         struct cli_state *cli;
7565         const char *dname = "\\testdir";
7566         const char *streamname =
7567                 "testdir:{4c8cc155-6c1e-11d1-8e41-00c04fb9386d}:$DATA";
7568         NTSTATUS status;
7569         time_t change_time, access_time, write_time;
7570         SMB_OFF_T size;
7571         uint16_t mode, fnum;
7572         bool ret = true;
7573
7574         if (!torture_open_connection(&cli, 0)) {
7575                 return false;
7576         }
7577
7578         cli_unlink(cli, "\\testdir\\*", FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
7579         cli_rmdir(cli, dname);
7580
7581         status = cli_mkdir(cli, dname);
7582         if (!NT_STATUS_IS_OK(status)) {
7583                 printf("mkdir failed: %s\n", nt_errstr(status));
7584                 return false;
7585         }
7586
7587         cli_qpathinfo1(cli, streamname, &change_time, &access_time, &write_time,
7588                       &size, &mode);
7589         status = cli_nt_error(cli);
7590
7591         if (!NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
7592                 printf("pathinfo returned %s, expected "
7593                        "NT_STATUS_OBJECT_NAME_NOT_FOUND\n",
7594                        nt_errstr(status));
7595                 ret = false;
7596         }
7597
7598         status = cli_ntcreate(cli, streamname, 0x16,
7599                               FILE_READ_DATA|FILE_READ_EA|
7600                               FILE_READ_ATTRIBUTES|READ_CONTROL_ACCESS,
7601                               FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ,
7602                               FILE_OPEN, 0, 0, &fnum);
7603
7604         if (!NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
7605                 printf("ntcreate returned %s, expected "
7606                        "NT_STATUS_OBJECT_NAME_NOT_FOUND\n",
7607                        nt_errstr(status));
7608                 ret = false;
7609         }
7610
7611
7612         cli_rmdir(cli, dname);
7613         return ret;
7614 }
7615
7616 static bool run_local_substitute(int dummy)
7617 {
7618         bool ok = true;
7619
7620         ok &= subst_test("%U", "bla", "", -1, -1, "bla");
7621         ok &= subst_test("%u%U", "bla", "", -1, -1, "blabla");
7622         ok &= subst_test("%g", "", "", -1, -1, "NO_GROUP");
7623         ok &= subst_test("%G", "", "", -1, -1, "NO_GROUP");
7624         ok &= subst_test("%g", "", "", -1, 0, gidtoname(0));
7625         ok &= subst_test("%G", "", "", -1, 0, gidtoname(0));
7626         ok &= subst_test("%D%u", "u", "dom", -1, 0, "domu");
7627         ok &= subst_test("%i %I", "", "", -1, -1, "0.0.0.0 0.0.0.0");
7628
7629         /* Different captialization rules in sub_basic... */
7630
7631         ok &=  (strcmp(talloc_sub_basic(talloc_tos(), "BLA", "dom", "%U%D"),
7632                        "blaDOM") == 0);
7633
7634         return ok;
7635 }
7636
7637 static bool run_local_base64(int dummy)
7638 {
7639         int i;
7640         bool ret = true;
7641
7642         for (i=1; i<2000; i++) {
7643                 DATA_BLOB blob1, blob2;
7644                 char *b64;
7645
7646                 blob1.data = talloc_array(talloc_tos(), uint8_t, i);
7647                 blob1.length = i;
7648                 generate_random_buffer(blob1.data, blob1.length);
7649
7650                 b64 = base64_encode_data_blob(talloc_tos(), blob1);
7651                 if (b64 == NULL) {
7652                         d_fprintf(stderr, "base64_encode_data_blob failed "
7653                                   "for %d bytes\n", i);
7654                         ret = false;
7655                 }
7656                 blob2 = base64_decode_data_blob(b64);
7657                 TALLOC_FREE(b64);
7658
7659                 if (data_blob_cmp(&blob1, &blob2)) {
7660                         d_fprintf(stderr, "data_blob_cmp failed for %d "
7661                                   "bytes\n", i);
7662                         ret = false;
7663                 }
7664                 TALLOC_FREE(blob1.data);
7665                 data_blob_free(&blob2);
7666         }
7667         return ret;
7668 }
7669
7670 static bool run_local_gencache(int dummy)
7671 {
7672         char *val;
7673         time_t tm;
7674         DATA_BLOB blob;
7675
7676         if (!gencache_set("foo", "bar", time(NULL) + 1000)) {
7677                 d_printf("%s: gencache_set() failed\n", __location__);
7678                 return False;
7679         }
7680
7681         if (!gencache_get("foo", NULL, NULL)) {
7682                 d_printf("%s: gencache_get() failed\n", __location__);
7683                 return False;
7684         }
7685
7686         if (!gencache_get("foo", &val, &tm)) {
7687                 d_printf("%s: gencache_get() failed\n", __location__);
7688                 return False;
7689         }
7690
7691         if (strcmp(val, "bar") != 0) {
7692                 d_printf("%s: gencache_get() returned %s, expected %s\n",
7693                          __location__, val, "bar");
7694                 SAFE_FREE(val);
7695                 return False;
7696         }
7697
7698         SAFE_FREE(val);
7699
7700         if (!gencache_del("foo")) {
7701                 d_printf("%s: gencache_del() failed\n", __location__);
7702                 return False;
7703         }
7704         if (gencache_del("foo")) {
7705                 d_printf("%s: second gencache_del() succeeded\n",
7706                          __location__);
7707                 return False;
7708         }
7709
7710         if (gencache_get("foo", &val, &tm)) {
7711                 d_printf("%s: gencache_get() on deleted entry "
7712                          "succeeded\n", __location__);
7713                 return False;
7714         }
7715
7716         blob = data_blob_string_const_null("bar");
7717         tm = time(NULL) + 60;
7718
7719         if (!gencache_set_data_blob("foo", &blob, tm)) {
7720                 d_printf("%s: gencache_set_data_blob() failed\n", __location__);
7721                 return False;
7722         }
7723
7724         if (!gencache_get_data_blob("foo", &blob, NULL, NULL)) {
7725                 d_printf("%s: gencache_get_data_blob() failed\n", __location__);
7726                 return False;
7727         }
7728
7729         if (strcmp((const char *)blob.data, "bar") != 0) {
7730                 d_printf("%s: gencache_get_data_blob() returned %s, expected %s\n",
7731                          __location__, (const char *)blob.data, "bar");
7732                 data_blob_free(&blob);
7733                 return False;
7734         }
7735
7736         data_blob_free(&blob);
7737
7738         if (!gencache_del("foo")) {
7739                 d_printf("%s: gencache_del() failed\n", __location__);
7740                 return False;
7741         }
7742         if (gencache_del("foo")) {
7743                 d_printf("%s: second gencache_del() succeeded\n",
7744                          __location__);
7745                 return False;
7746         }
7747
7748         if (gencache_get_data_blob("foo", &blob, NULL, NULL)) {
7749                 d_printf("%s: gencache_get_data_blob() on deleted entry "
7750                          "succeeded\n", __location__);
7751                 return False;
7752         }
7753
7754         return True;
7755 }
7756
7757 static bool rbt_testval(struct db_context *db, const char *key,
7758                         const char *value)
7759 {
7760         struct db_record *rec;
7761         TDB_DATA data = string_tdb_data(value);
7762         bool ret = false;
7763         NTSTATUS status;
7764
7765         rec = db->fetch_locked(db, db, string_tdb_data(key));
7766         if (rec == NULL) {
7767                 d_fprintf(stderr, "fetch_locked failed\n");
7768                 goto done;
7769         }
7770         status = rec->store(rec, data, 0);
7771         if (!NT_STATUS_IS_OK(status)) {
7772                 d_fprintf(stderr, "store failed: %s\n", nt_errstr(status));
7773                 goto done;
7774         }
7775         TALLOC_FREE(rec);
7776
7777         rec = db->fetch_locked(db, db, string_tdb_data(key));
7778         if (rec == NULL) {
7779                 d_fprintf(stderr, "second fetch_locked failed\n");
7780                 goto done;
7781         }
7782         if ((rec->value.dsize != data.dsize)
7783             || (memcmp(rec->value.dptr, data.dptr, data.dsize) != 0)) {
7784                 d_fprintf(stderr, "Got wrong data back\n");
7785                 goto done;
7786         }
7787
7788         ret = true;
7789  done:
7790         TALLOC_FREE(rec);
7791         return ret;
7792 }
7793
7794 static bool run_local_rbtree(int dummy)
7795 {
7796         struct db_context *db;
7797         bool ret = false;
7798         int i;
7799
7800         db = db_open_rbt(NULL);
7801
7802         if (db == NULL) {
7803                 d_fprintf(stderr, "db_open_rbt failed\n");
7804                 return false;
7805         }
7806
7807         for (i=0; i<1000; i++) {
7808                 char *key, *value;
7809
7810                 if (asprintf(&key, "key%ld", random()) == -1) {
7811                         goto done;
7812                 }
7813                 if (asprintf(&value, "value%ld", random()) == -1) {
7814                         SAFE_FREE(key);
7815                         goto done;
7816                 }
7817
7818                 if (!rbt_testval(db, key, value)) {
7819                         SAFE_FREE(key);
7820                         SAFE_FREE(value);
7821                         goto done;
7822                 }
7823
7824                 SAFE_FREE(value);
7825                 if (asprintf(&value, "value%ld", random()) == -1) {
7826                         SAFE_FREE(key);
7827                         goto done;
7828                 }
7829
7830                 if (!rbt_testval(db, key, value)) {
7831                         SAFE_FREE(key);
7832                         SAFE_FREE(value);
7833                         goto done;
7834                 }
7835
7836                 SAFE_FREE(key);
7837                 SAFE_FREE(value);
7838         }
7839
7840         ret = true;
7841
7842  done:
7843         TALLOC_FREE(db);
7844         return ret;
7845 }
7846
7847
7848 /*
7849   local test for character set functions
7850
7851   This is a very simple test for the functionality in convert_string_error()
7852  */
7853 static bool run_local_convert_string(int dummy)
7854 {
7855         TALLOC_CTX *tmp_ctx = talloc_new(NULL);
7856         const char *test_strings[2] = { "March", "M\303\244rz" };
7857         char dst[7];
7858         int i;
7859
7860         for (i=0; i<2; i++) {
7861                 const char *str = test_strings[i];
7862                 int len = strlen(str);
7863                 size_t converted_size;
7864                 bool ret;
7865
7866                 memset(dst, 'X', sizeof(dst));
7867
7868                 /* first try with real source length */
7869                 ret = convert_string_error(CH_UNIX, CH_UTF8,
7870                                            str, len,
7871                                            dst, sizeof(dst),
7872                                            &converted_size);
7873                 if (ret != true) {
7874                         d_fprintf(stderr, "Failed to convert '%s' to CH_DISPLAY\n", str);
7875                         goto failed;
7876                 }
7877
7878                 if (converted_size != len) {
7879                         d_fprintf(stderr, "Converted size of '%s' should be %d - got %d\n",
7880                                   str, len, (int)converted_size);
7881                         goto failed;
7882                 }
7883
7884                 if (strncmp(str, dst, converted_size) != 0) {
7885                         d_fprintf(stderr, "Expected '%s' to match '%s'\n", str, dst);
7886                         goto failed;
7887                 }
7888
7889                 if (strlen(str) != converted_size) {
7890                         d_fprintf(stderr, "Expected '%s' length %d - got %d\n", str,
7891                                   (int)strlen(str), (int)converted_size);
7892                         goto failed;
7893                 }
7894
7895                 if (dst[converted_size] != 'X') {
7896                         d_fprintf(stderr, "Expected no termination of '%s'\n", dst);
7897                         goto failed;
7898                 }
7899
7900                 /* now with srclen==-1, this causes the nul to be
7901                  * converted too */
7902                 ret = convert_string_error(CH_UNIX, CH_UTF8,
7903                                            str, -1,
7904                                            dst, sizeof(dst),
7905                                            &converted_size);
7906                 if (ret != true) {
7907                         d_fprintf(stderr, "Failed to convert '%s' to CH_DISPLAY\n", str);
7908                         goto failed;
7909                 }
7910
7911                 if (converted_size != len+1) {
7912                         d_fprintf(stderr, "Converted size of '%s' should be %d - got %d\n",
7913                                   str, len, (int)converted_size);
7914                         goto failed;
7915                 }
7916
7917                 if (strncmp(str, dst, converted_size) != 0) {
7918                         d_fprintf(stderr, "Expected '%s' to match '%s'\n", str, dst);
7919                         goto failed;
7920                 }
7921
7922                 if (len+1 != converted_size) {
7923                         d_fprintf(stderr, "Expected '%s' length %d - got %d\n", str,
7924                                   len+1, (int)converted_size);
7925                         goto failed;
7926                 }
7927
7928                 if (dst[converted_size] != 'X') {
7929                         d_fprintf(stderr, "Expected no termination of '%s'\n", dst);
7930                         goto failed;
7931                 }
7932
7933         }
7934
7935
7936         TALLOC_FREE(tmp_ctx);
7937         return true;
7938 failed:
7939         TALLOC_FREE(tmp_ctx);
7940         return false;
7941 }
7942
7943
7944 struct talloc_dict_test {
7945         int content;
7946 };
7947
7948 static int talloc_dict_traverse_fn(DATA_BLOB key, void *data, void *priv)
7949 {
7950         int *count = (int *)priv;
7951         *count += 1;
7952         return 0;
7953 }
7954
7955 static bool run_local_talloc_dict(int dummy)
7956 {
7957         struct talloc_dict *dict;
7958         struct talloc_dict_test *t;
7959         int key, count;
7960
7961         dict = talloc_dict_init(talloc_tos());
7962         if (dict == NULL) {
7963                 return false;
7964         }
7965
7966         t = talloc(talloc_tos(), struct talloc_dict_test);
7967         if (t == NULL) {
7968                 return false;
7969         }
7970
7971         key = 1;
7972         t->content = 1;
7973         if (!talloc_dict_set(dict, data_blob_const(&key, sizeof(key)), t)) {
7974                 return false;
7975         }
7976
7977         count = 0;
7978         if (talloc_dict_traverse(dict, talloc_dict_traverse_fn, &count) != 0) {
7979                 return false;
7980         }
7981
7982         if (count != 1) {
7983                 return false;
7984         }
7985
7986         TALLOC_FREE(dict);
7987
7988         return true;
7989 }
7990
7991 static bool run_local_string_to_sid(int dummy) {
7992         struct dom_sid sid;
7993
7994         if (string_to_sid(&sid, "S--1-5-32-545")) {
7995                 printf("allowing S--1-5-32-545\n");
7996                 return false;
7997         }
7998         if (string_to_sid(&sid, "S-1-5-32-+545")) {
7999                 printf("allowing S-1-5-32-+545\n");
8000                 return false;
8001         }
8002         if (string_to_sid(&sid, "S-1-2-3-4-5-6-7-8-9-0-1-2-3-4-5-6-7-8-9-0")) {
8003                 printf("allowing S-1-2-3-4-5-6-7-8-9-0-1-2-3-4-5-6-7-8-9-0\n");
8004                 return false;
8005         }
8006         if (string_to_sid(&sid, "S-1-5-32-545-abc")) {
8007                 printf("allowing S-1-5-32-545-abc\n");
8008                 return false;
8009         }
8010         if (!string_to_sid(&sid, "S-1-5-32-545")) {
8011                 printf("could not parse S-1-5-32-545\n");
8012                 return false;
8013         }
8014         if (!dom_sid_equal(&sid, &global_sid_Builtin_Users)) {
8015                 printf("mis-parsed S-1-5-32-545 as %s\n",
8016                        sid_string_tos(&sid));
8017                 return false;
8018         }
8019         return true;
8020 }
8021
8022 static bool run_local_binary_to_sid(int dummy) {
8023         struct dom_sid *sid = talloc(NULL, struct dom_sid);
8024         static const char good_binary_sid[] = {
8025                 0x1, /* revision number */
8026                 15, /* num auths */
8027                 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, /* id_auth */
8028                 0x1, 0x1, 0x1, 0x1, /* auth[0] */
8029                 0x1, 0x1, 0x1, 0x1, /* auth[1] */
8030                 0x1, 0x1, 0x1, 0x1, /* auth[2] */
8031                 0x1, 0x1, 0x1, 0x1, /* auth[3] */
8032                 0x1, 0x1, 0x1, 0x1, /* auth[4] */
8033                 0x1, 0x1, 0x1, 0x1, /* auth[5] */
8034                 0x1, 0x1, 0x1, 0x1, /* auth[6] */
8035                 0x1, 0x1, 0x1, 0x1, /* auth[7] */
8036                 0x1, 0x1, 0x1, 0x1, /* auth[8] */
8037                 0x1, 0x1, 0x1, 0x1, /* auth[9] */
8038                 0x1, 0x1, 0x1, 0x1, /* auth[10] */
8039                 0x1, 0x1, 0x1, 0x1, /* auth[11] */
8040                 0x1, 0x1, 0x1, 0x1, /* auth[12] */
8041                 0x1, 0x1, 0x1, 0x1, /* auth[13] */
8042                 0x1, 0x1, 0x1, 0x1, /* auth[14] */
8043         };
8044
8045         static const char long_binary_sid[] = {
8046                 0x1, /* revision number */
8047                 15, /* num auths */
8048                 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, /* id_auth */
8049                 0x1, 0x1, 0x1, 0x1, /* auth[0] */
8050                 0x1, 0x1, 0x1, 0x1, /* auth[1] */
8051                 0x1, 0x1, 0x1, 0x1, /* auth[2] */
8052                 0x1, 0x1, 0x1, 0x1, /* auth[3] */
8053                 0x1, 0x1, 0x1, 0x1, /* auth[4] */
8054                 0x1, 0x1, 0x1, 0x1, /* auth[5] */
8055                 0x1, 0x1, 0x1, 0x1, /* auth[6] */
8056                 0x1, 0x1, 0x1, 0x1, /* auth[7] */
8057                 0x1, 0x1, 0x1, 0x1, /* auth[8] */
8058                 0x1, 0x1, 0x1, 0x1, /* auth[9] */
8059                 0x1, 0x1, 0x1, 0x1, /* auth[10] */
8060                 0x1, 0x1, 0x1, 0x1, /* auth[11] */
8061                 0x1, 0x1, 0x1, 0x1, /* auth[12] */
8062                 0x1, 0x1, 0x1, 0x1, /* auth[13] */
8063                 0x1, 0x1, 0x1, 0x1, /* auth[14] */
8064                 0x1, 0x1, 0x1, 0x1, /* auth[15] */
8065                 0x1, 0x1, 0x1, 0x1, /* auth[16] */
8066                 0x1, 0x1, 0x1, 0x1, /* auth[17] */
8067         };
8068
8069         static const char long_binary_sid2[] = {
8070                 0x1, /* revision number */
8071                 32, /* num auths */
8072                 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, /* id_auth */
8073                 0x1, 0x1, 0x1, 0x1, /* auth[0] */
8074                 0x1, 0x1, 0x1, 0x1, /* auth[1] */
8075                 0x1, 0x1, 0x1, 0x1, /* auth[2] */
8076                 0x1, 0x1, 0x1, 0x1, /* auth[3] */
8077                 0x1, 0x1, 0x1, 0x1, /* auth[4] */
8078                 0x1, 0x1, 0x1, 0x1, /* auth[5] */
8079                 0x1, 0x1, 0x1, 0x1, /* auth[6] */
8080                 0x1, 0x1, 0x1, 0x1, /* auth[7] */
8081                 0x1, 0x1, 0x1, 0x1, /* auth[8] */
8082                 0x1, 0x1, 0x1, 0x1, /* auth[9] */
8083                 0x1, 0x1, 0x1, 0x1, /* auth[10] */
8084                 0x1, 0x1, 0x1, 0x1, /* auth[11] */
8085                 0x1, 0x1, 0x1, 0x1, /* auth[12] */
8086                 0x1, 0x1, 0x1, 0x1, /* auth[13] */
8087                 0x1, 0x1, 0x1, 0x1, /* auth[14] */
8088                 0x1, 0x1, 0x1, 0x1, /* auth[15] */
8089                 0x1, 0x1, 0x1, 0x1, /* auth[16] */
8090                 0x1, 0x1, 0x1, 0x1, /* auth[17] */
8091                 0x1, 0x1, 0x1, 0x1, /* auth[18] */
8092                 0x1, 0x1, 0x1, 0x1, /* auth[19] */
8093                 0x1, 0x1, 0x1, 0x1, /* auth[20] */
8094                 0x1, 0x1, 0x1, 0x1, /* auth[21] */
8095                 0x1, 0x1, 0x1, 0x1, /* auth[22] */
8096                 0x1, 0x1, 0x1, 0x1, /* auth[23] */
8097                 0x1, 0x1, 0x1, 0x1, /* auth[24] */
8098                 0x1, 0x1, 0x1, 0x1, /* auth[25] */
8099                 0x1, 0x1, 0x1, 0x1, /* auth[26] */
8100                 0x1, 0x1, 0x1, 0x1, /* auth[27] */
8101                 0x1, 0x1, 0x1, 0x1, /* auth[28] */
8102                 0x1, 0x1, 0x1, 0x1, /* auth[29] */
8103                 0x1, 0x1, 0x1, 0x1, /* auth[30] */
8104                 0x1, 0x1, 0x1, 0x1, /* auth[31] */
8105         };
8106
8107         if (!sid_parse(good_binary_sid, sizeof(good_binary_sid), sid)) {
8108                 return false;
8109         }
8110         if (sid_parse(long_binary_sid2, sizeof(long_binary_sid2), sid)) {
8111                 return false;
8112         }
8113         if (sid_parse(long_binary_sid, sizeof(long_binary_sid), sid)) {
8114                 return false;
8115         }
8116         return true;
8117 }
8118
8119 /* Split a path name into filename and stream name components. Canonicalise
8120  * such that an implicit $DATA token is always explicit.
8121  *
8122  * The "specification" of this function can be found in the
8123  * run_local_stream_name() function in torture.c, I've tried those
8124  * combinations against a W2k3 server.
8125  */
8126
8127 static NTSTATUS split_ntfs_stream_name(TALLOC_CTX *mem_ctx, const char *fname,
8128                                        char **pbase, char **pstream)
8129 {
8130         char *base = NULL;
8131         char *stream = NULL;
8132         char *sname; /* stream name */
8133         const char *stype; /* stream type */
8134
8135         DEBUG(10, ("split_ntfs_stream_name called for [%s]\n", fname));
8136
8137         sname = strchr_m(fname, ':');
8138
8139         if (lp_posix_pathnames() || (sname == NULL)) {
8140                 if (pbase != NULL) {
8141                         base = talloc_strdup(mem_ctx, fname);
8142                         NT_STATUS_HAVE_NO_MEMORY(base);
8143                 }
8144                 goto done;
8145         }
8146
8147         if (pbase != NULL) {
8148                 base = talloc_strndup(mem_ctx, fname, PTR_DIFF(sname, fname));
8149                 NT_STATUS_HAVE_NO_MEMORY(base);
8150         }
8151
8152         sname += 1;
8153
8154         stype = strchr_m(sname, ':');
8155
8156         if (stype == NULL) {
8157                 sname = talloc_strdup(mem_ctx, sname);
8158                 stype = "$DATA";
8159         }
8160         else {
8161                 if (strcasecmp_m(stype, ":$DATA") != 0) {
8162                         /*
8163                          * If there is an explicit stream type, so far we only
8164                          * allow $DATA. Is there anything else allowed? -- vl
8165                          */
8166                         DEBUG(10, ("[%s] is an invalid stream type\n", stype));
8167                         TALLOC_FREE(base);
8168                         return NT_STATUS_OBJECT_NAME_INVALID;
8169                 }
8170                 sname = talloc_strndup(mem_ctx, sname, PTR_DIFF(stype, sname));
8171                 stype += 1;
8172         }
8173
8174         if (sname == NULL) {
8175                 TALLOC_FREE(base);
8176                 return NT_STATUS_NO_MEMORY;
8177         }
8178
8179         if (sname[0] == '\0') {
8180                 /*
8181                  * no stream name, so no stream
8182                  */
8183                 goto done;
8184         }
8185
8186         if (pstream != NULL) {
8187                 stream = talloc_asprintf(mem_ctx, "%s:%s", sname, stype);
8188                 if (stream == NULL) {
8189                         TALLOC_FREE(sname);
8190                         TALLOC_FREE(base);
8191                         return NT_STATUS_NO_MEMORY;
8192                 }
8193                 /*
8194                  * upper-case the type field
8195                  */
8196                 strupper_m(strchr_m(stream, ':')+1);
8197         }
8198
8199  done:
8200         if (pbase != NULL) {
8201                 *pbase = base;
8202         }
8203         if (pstream != NULL) {
8204                 *pstream = stream;
8205         }
8206         return NT_STATUS_OK;
8207 }
8208
8209 static bool test_stream_name(const char *fname, const char *expected_base,
8210                              const char *expected_stream,
8211                              NTSTATUS expected_status)
8212 {
8213         NTSTATUS status;
8214         char *base = NULL;
8215         char *stream = NULL;
8216
8217         status = split_ntfs_stream_name(talloc_tos(), fname, &base, &stream);
8218         if (!NT_STATUS_EQUAL(status, expected_status)) {
8219                 goto error;
8220         }
8221
8222         if (!NT_STATUS_IS_OK(status)) {
8223                 return true;
8224         }
8225
8226         if (base == NULL) goto error;
8227
8228         if (strcmp(expected_base, base) != 0) goto error;
8229
8230         if ((expected_stream != NULL) && (stream == NULL)) goto error;
8231         if ((expected_stream == NULL) && (stream != NULL)) goto error;
8232
8233         if ((stream != NULL) && (strcmp(expected_stream, stream) != 0))
8234                 goto error;
8235
8236         TALLOC_FREE(base);
8237         TALLOC_FREE(stream);
8238         return true;
8239
8240  error:
8241         d_fprintf(stderr, "Do test_stream(%s, %s, %s, %s)\n",
8242                   fname, expected_base ? expected_base : "<NULL>",
8243                   expected_stream ? expected_stream : "<NULL>",
8244                   nt_errstr(expected_status));
8245         d_fprintf(stderr, "-> base=%s, stream=%s, status=%s\n",
8246                   base ? base : "<NULL>", stream ? stream : "<NULL>",
8247                   nt_errstr(status));
8248         TALLOC_FREE(base);
8249         TALLOC_FREE(stream);
8250         return false;
8251 }
8252
8253 static bool run_local_stream_name(int dummy)
8254 {
8255         bool ret = true;
8256
8257         ret &= test_stream_name(
8258                 "bla", "bla", NULL, NT_STATUS_OK);
8259         ret &= test_stream_name(
8260                 "bla::$DATA", "bla", NULL, NT_STATUS_OK);
8261         ret &= test_stream_name(
8262                 "bla:blub:", "bla", NULL, NT_STATUS_OBJECT_NAME_INVALID);
8263         ret &= test_stream_name(
8264                 "bla::", NULL, NULL, NT_STATUS_OBJECT_NAME_INVALID);
8265         ret &= test_stream_name(
8266                 "bla::123", "bla", NULL, NT_STATUS_OBJECT_NAME_INVALID);
8267         ret &= test_stream_name(
8268                 "bla:$DATA", "bla", "$DATA:$DATA", NT_STATUS_OK);
8269         ret &= test_stream_name(
8270                 "bla:x:$DATA", "bla", "x:$DATA", NT_STATUS_OK);
8271         ret &= test_stream_name(
8272                 "bla:x", "bla", "x:$DATA", NT_STATUS_OK);
8273
8274         return ret;
8275 }
8276
8277 static bool data_blob_equal(DATA_BLOB a, DATA_BLOB b)
8278 {
8279         if (a.length != b.length) {
8280                 printf("a.length=%d != b.length=%d\n",
8281                        (int)a.length, (int)b.length);
8282                 return false;
8283         }
8284         if (memcmp(a.data, b.data, a.length) != 0) {
8285                 printf("a.data and b.data differ\n");
8286                 return false;
8287         }
8288         return true;
8289 }
8290
8291 static bool run_local_memcache(int dummy)
8292 {
8293         struct memcache *cache;
8294         DATA_BLOB k1, k2;
8295         DATA_BLOB d1, d2, d3;
8296         DATA_BLOB v1, v2, v3;
8297
8298         TALLOC_CTX *mem_ctx;
8299         char *str1, *str2;
8300         size_t size1, size2;
8301         bool ret = false;
8302
8303         cache = memcache_init(NULL, 100);
8304
8305         if (cache == NULL) {
8306                 printf("memcache_init failed\n");
8307                 return false;
8308         }
8309
8310         d1 = data_blob_const("d1", 2);
8311         d2 = data_blob_const("d2", 2);
8312         d3 = data_blob_const("d3", 2);
8313
8314         k1 = data_blob_const("d1", 2);
8315         k2 = data_blob_const("d2", 2);
8316
8317         memcache_add(cache, STAT_CACHE, k1, d1);
8318         memcache_add(cache, GETWD_CACHE, k2, d2);
8319
8320         if (!memcache_lookup(cache, STAT_CACHE, k1, &v1)) {
8321                 printf("could not find k1\n");
8322                 return false;
8323         }
8324         if (!data_blob_equal(d1, v1)) {
8325                 return false;
8326         }
8327
8328         if (!memcache_lookup(cache, GETWD_CACHE, k2, &v2)) {
8329                 printf("could not find k2\n");
8330                 return false;
8331         }
8332         if (!data_blob_equal(d2, v2)) {
8333                 return false;
8334         }
8335
8336         memcache_add(cache, STAT_CACHE, k1, d3);
8337
8338         if (!memcache_lookup(cache, STAT_CACHE, k1, &v3)) {
8339                 printf("could not find replaced k1\n");
8340                 return false;
8341         }
8342         if (!data_blob_equal(d3, v3)) {
8343                 return false;
8344         }
8345
8346         memcache_add(cache, GETWD_CACHE, k1, d1);
8347
8348         if (memcache_lookup(cache, GETWD_CACHE, k2, &v2)) {
8349                 printf("Did find k2, should have been purged\n");
8350                 return false;
8351         }
8352
8353         TALLOC_FREE(cache);
8354
8355         cache = memcache_init(NULL, 0);
8356
8357         mem_ctx = talloc_init("foo");
8358
8359         str1 = talloc_strdup(mem_ctx, "string1");
8360         str2 = talloc_strdup(mem_ctx, "string2");
8361
8362         memcache_add_talloc(cache, SINGLETON_CACHE_TALLOC,
8363                             data_blob_string_const("torture"), &str1);
8364         size1 = talloc_total_size(cache);
8365
8366         memcache_add_talloc(cache, SINGLETON_CACHE_TALLOC,
8367                             data_blob_string_const("torture"), &str2);
8368         size2 = talloc_total_size(cache);
8369
8370         printf("size1=%d, size2=%d\n", (int)size1, (int)size2);
8371
8372         if (size2 > size1) {
8373                 printf("memcache leaks memory!\n");
8374                 goto fail;
8375         }
8376
8377         ret = true;
8378  fail:
8379         TALLOC_FREE(cache);
8380         return ret;
8381 }
8382
8383 static void wbclient_done(struct tevent_req *req)
8384 {
8385         wbcErr wbc_err;
8386         struct winbindd_response *wb_resp;
8387         int *i = (int *)tevent_req_callback_data_void(req);
8388
8389         wbc_err = wb_trans_recv(req, req, &wb_resp);
8390         TALLOC_FREE(req);
8391         *i += 1;
8392         d_printf("wb_trans_recv %d returned %s\n", *i, wbcErrorString(wbc_err));
8393 }
8394
8395 static bool run_local_wbclient(int dummy)
8396 {
8397         struct event_context *ev;
8398         struct wb_context **wb_ctx;
8399         struct winbindd_request wb_req;
8400         bool result = false;
8401         int i, j;
8402
8403         BlockSignals(True, SIGPIPE);
8404
8405         ev = tevent_context_init_byname(talloc_tos(), "epoll");
8406         if (ev == NULL) {
8407                 goto fail;
8408         }
8409
8410         wb_ctx = talloc_array(ev, struct wb_context *, nprocs);
8411         if (wb_ctx == NULL) {
8412                 goto fail;
8413         }
8414
8415         ZERO_STRUCT(wb_req);
8416         wb_req.cmd = WINBINDD_PING;
8417
8418         d_printf("nprocs=%d, numops=%d\n", (int)nprocs, (int)torture_numops);
8419
8420         for (i=0; i<nprocs; i++) {
8421                 wb_ctx[i] = wb_context_init(ev, NULL);
8422                 if (wb_ctx[i] == NULL) {
8423                         goto fail;
8424                 }
8425                 for (j=0; j<torture_numops; j++) {
8426                         struct tevent_req *req;
8427                         req = wb_trans_send(ev, ev, wb_ctx[i],
8428                                             (j % 2) == 0, &wb_req);
8429                         if (req == NULL) {
8430                                 goto fail;
8431                         }
8432                         tevent_req_set_callback(req, wbclient_done, &i);
8433                 }
8434         }
8435
8436         i = 0;
8437
8438         while (i < nprocs * torture_numops) {
8439                 tevent_loop_once(ev);
8440         }
8441
8442         result = true;
8443  fail:
8444         TALLOC_FREE(ev);
8445         return result;
8446 }
8447
8448 static void getaddrinfo_finished(struct tevent_req *req)
8449 {
8450         char *name = (char *)tevent_req_callback_data_void(req);
8451         struct addrinfo *ainfo;
8452         int res;
8453
8454         res = getaddrinfo_recv(req, &ainfo);
8455         if (res != 0) {
8456                 d_printf("gai(%s) returned %s\n", name, gai_strerror(res));
8457                 return;
8458         }
8459         d_printf("gai(%s) succeeded\n", name);
8460         freeaddrinfo(ainfo);
8461 }
8462
8463 static bool run_getaddrinfo_send(int dummy)
8464 {
8465         TALLOC_CTX *frame = talloc_stackframe();
8466         struct fncall_context *ctx;
8467         struct tevent_context *ev;
8468         bool result = false;
8469         const char *names[4] = { "www.samba.org", "notfound.samba.org",
8470                                  "www.slashdot.org", "heise.de" };
8471         struct tevent_req *reqs[4];
8472         int i;
8473
8474         ev = event_context_init(frame);
8475         if (ev == NULL) {
8476                 goto fail;
8477         }
8478
8479         ctx = fncall_context_init(frame, 4);
8480
8481         for (i=0; i<ARRAY_SIZE(names); i++) {
8482                 reqs[i] = getaddrinfo_send(frame, ev, ctx, names[i], NULL,
8483                                            NULL);
8484                 if (reqs[i] == NULL) {
8485                         goto fail;
8486                 }
8487                 tevent_req_set_callback(reqs[i], getaddrinfo_finished,
8488                                         discard_const_p(void, names[i]));
8489         }
8490
8491         for (i=0; i<ARRAY_SIZE(reqs); i++) {
8492                 tevent_loop_once(ev);
8493         }
8494
8495         result = true;
8496 fail:
8497         TALLOC_FREE(frame);
8498         return result;
8499 }
8500
8501 static bool dbtrans_inc(struct db_context *db)
8502 {
8503         struct db_record *rec;
8504         uint32_t *val;
8505         bool ret = false;
8506         NTSTATUS status;
8507
8508         rec = db->fetch_locked(db, db, string_term_tdb_data("transtest"));
8509         if (rec == NULL) {
8510                 printf(__location__ "fetch_lock failed\n");
8511                 return false;
8512         }
8513
8514         if (rec->value.dsize != sizeof(uint32_t)) {
8515                 printf(__location__ "value.dsize = %d\n",
8516                        (int)rec->value.dsize);
8517                 goto fail;
8518         }
8519
8520         val = (uint32_t *)rec->value.dptr;
8521         *val += 1;
8522
8523         status = rec->store(rec, make_tdb_data((uint8_t *)val,
8524                                                sizeof(uint32_t)),
8525                             0);
8526         if (!NT_STATUS_IS_OK(status)) {
8527                 printf(__location__ "store failed: %s\n",
8528                        nt_errstr(status));
8529                 goto fail;
8530         }
8531
8532         ret = true;
8533 fail:
8534         TALLOC_FREE(rec);
8535         return ret;
8536 }
8537
8538 static bool run_local_dbtrans(int dummy)
8539 {
8540         struct db_context *db;
8541         struct db_record *rec;
8542         NTSTATUS status;
8543         uint32_t initial;
8544         int res;
8545
8546         db = db_open(talloc_tos(), "transtest.tdb", 0, TDB_DEFAULT,
8547                      O_RDWR|O_CREAT, 0600);
8548         if (db == NULL) {
8549                 printf("Could not open transtest.db\n");
8550                 return false;
8551         }
8552
8553         res = db->transaction_start(db);
8554         if (res != 0) {
8555                 printf(__location__ "transaction_start failed\n");
8556                 return false;
8557         }
8558
8559         rec = db->fetch_locked(db, db, string_term_tdb_data("transtest"));
8560         if (rec == NULL) {
8561                 printf(__location__ "fetch_lock failed\n");
8562                 return false;
8563         }
8564
8565         if (rec->value.dptr == NULL) {
8566                 initial = 0;
8567                 status = rec->store(
8568                         rec, make_tdb_data((uint8_t *)&initial,
8569                                            sizeof(initial)),
8570                         0);
8571                 if (!NT_STATUS_IS_OK(status)) {
8572                         printf(__location__ "store returned %s\n",
8573                                nt_errstr(status));
8574                         return false;
8575                 }
8576         }
8577
8578         TALLOC_FREE(rec);
8579
8580         res = db->transaction_commit(db);
8581         if (res != 0) {
8582                 printf(__location__ "transaction_commit failed\n");
8583                 return false;
8584         }
8585
8586         while (true) {
8587                 uint32_t val, val2;
8588                 int i;
8589
8590                 res = db->transaction_start(db);
8591                 if (res != 0) {
8592                         printf(__location__ "transaction_start failed\n");
8593                         break;
8594                 }
8595
8596                 if (!dbwrap_fetch_uint32(db, "transtest", &val)) {
8597                         printf(__location__ "dbwrap_fetch_uint32 failed\n");
8598                         break;
8599                 }
8600
8601                 for (i=0; i<10; i++) {
8602                         if (!dbtrans_inc(db)) {
8603                                 return false;
8604                         }
8605                 }
8606
8607                 if (!dbwrap_fetch_uint32(db, "transtest", &val2)) {
8608                         printf(__location__ "dbwrap_fetch_uint32 failed\n");
8609                         break;
8610                 }
8611
8612                 if (val2 != val + 10) {
8613                         printf(__location__ "val=%d, val2=%d\n",
8614                                (int)val, (int)val2);
8615                         break;
8616                 }
8617
8618                 printf("val2=%d\r", val2);
8619
8620                 res = db->transaction_commit(db);
8621                 if (res != 0) {
8622                         printf(__location__ "transaction_commit failed\n");
8623                         break;
8624                 }
8625         }
8626
8627         TALLOC_FREE(db);
8628         return true;
8629 }
8630
8631 /*
8632  * Just a dummy test to be run under a debugger. There's no real way
8633  * to inspect the tevent_select specific function from outside of
8634  * tevent_select.c.
8635  */
8636
8637 static bool run_local_tevent_select(int dummy)
8638 {
8639         struct tevent_context *ev;
8640         struct tevent_fd *fd1, *fd2;
8641         bool result = false;
8642
8643         ev = tevent_context_init_byname(NULL, "select");
8644         if (ev == NULL) {
8645                 d_fprintf(stderr, "tevent_context_init_byname failed\n");
8646                 goto fail;
8647         }
8648
8649         fd1 = tevent_add_fd(ev, ev, 2, 0, NULL, NULL);
8650         if (fd1 == NULL) {
8651                 d_fprintf(stderr, "tevent_add_fd failed\n");
8652                 goto fail;
8653         }
8654         fd2 = tevent_add_fd(ev, ev, 3, 0, NULL, NULL);
8655         if (fd2 == NULL) {
8656                 d_fprintf(stderr, "tevent_add_fd failed\n");
8657                 goto fail;
8658         }
8659         TALLOC_FREE(fd2);
8660
8661         fd2 = tevent_add_fd(ev, ev, 1, 0, NULL, NULL);
8662         if (fd2 == NULL) {
8663                 d_fprintf(stderr, "tevent_add_fd failed\n");
8664                 goto fail;
8665         }
8666
8667         result = true;
8668 fail:
8669         TALLOC_FREE(ev);
8670         return result;
8671 }
8672
8673 static double create_procs(bool (*fn)(int), bool *result)
8674 {
8675         int i, status;
8676         volatile pid_t *child_status;
8677         volatile bool *child_status_out;
8678         int synccount;
8679         int tries = 8;
8680         struct timeval start;
8681
8682         synccount = 0;
8683
8684         child_status = (volatile pid_t *)shm_setup(sizeof(pid_t)*nprocs);
8685         if (!child_status) {
8686                 printf("Failed to setup shared memory\n");
8687                 return -1;
8688         }
8689
8690         child_status_out = (volatile bool *)shm_setup(sizeof(bool)*nprocs);
8691         if (!child_status_out) {
8692                 printf("Failed to setup result status shared memory\n");
8693                 return -1;
8694         }
8695
8696         for (i = 0; i < nprocs; i++) {
8697                 child_status[i] = 0;
8698                 child_status_out[i] = True;
8699         }
8700
8701         start = timeval_current();
8702
8703         for (i=0;i<nprocs;i++) {
8704                 procnum = i;
8705                 if (fork() == 0) {
8706                         pid_t mypid = getpid();
8707                         sys_srandom(((int)mypid) ^ ((int)time(NULL)));
8708
8709                         slprintf(myname,sizeof(myname),"CLIENT%d", i);
8710
8711                         while (1) {
8712                                 if (torture_open_connection(&current_cli, i)) break;
8713                                 if (tries-- == 0) {
8714                                         printf("pid %d failed to start\n", (int)getpid());
8715                                         _exit(1);
8716                                 }
8717                                 smb_msleep(10);
8718                         }
8719
8720                         child_status[i] = getpid();
8721
8722                         while (child_status[i] && timeval_elapsed(&start) < 5) smb_msleep(2);
8723
8724                         child_status_out[i] = fn(i);
8725                         _exit(0);
8726                 }
8727         }
8728
8729         do {
8730                 synccount = 0;
8731                 for (i=0;i<nprocs;i++) {
8732                         if (child_status[i]) synccount++;
8733                 }
8734                 if (synccount == nprocs) break;
8735                 smb_msleep(10);
8736         } while (timeval_elapsed(&start) < 30);
8737
8738         if (synccount != nprocs) {
8739                 printf("FAILED TO START %d CLIENTS (started %d)\n", nprocs, synccount);
8740                 *result = False;
8741                 return timeval_elapsed(&start);
8742         }
8743
8744         /* start the client load */
8745         start = timeval_current();
8746
8747         for (i=0;i<nprocs;i++) {
8748                 child_status[i] = 0;
8749         }
8750
8751         printf("%d clients started\n", nprocs);
8752
8753         for (i=0;i<nprocs;i++) {
8754                 while (waitpid(0, &status, 0) == -1 && errno == EINTR) /* noop */ ;
8755         }
8756
8757         printf("\n");
8758
8759         for (i=0;i<nprocs;i++) {
8760                 if (!child_status_out[i]) {
8761                         *result = False;
8762                 }
8763         }
8764         return timeval_elapsed(&start);
8765 }
8766
8767 #define FLAG_MULTIPROC 1
8768
8769 static struct {
8770         const char *name;
8771         bool (*fn)(int);
8772         unsigned flags;
8773 } torture_ops[] = {
8774         {"FDPASS", run_fdpasstest, 0},
8775         {"LOCK1",  run_locktest1,  0},
8776         {"LOCK2",  run_locktest2,  0},
8777         {"LOCK3",  run_locktest3,  0},
8778         {"LOCK4",  run_locktest4,  0},
8779         {"LOCK5",  run_locktest5,  0},
8780         {"LOCK6",  run_locktest6,  0},
8781         {"LOCK7",  run_locktest7,  0},
8782         {"LOCK8",  run_locktest8,  0},
8783         {"LOCK9",  run_locktest9,  0},
8784         {"UNLINK", run_unlinktest, 0},
8785         {"BROWSE", run_browsetest, 0},
8786         {"ATTR",   run_attrtest,   0},
8787         {"TRANS2", run_trans2test, 0},
8788         {"MAXFID", run_maxfidtest, FLAG_MULTIPROC},
8789         {"TORTURE",run_torture,    FLAG_MULTIPROC},
8790         {"RANDOMIPC", run_randomipc, 0},
8791         {"NEGNOWAIT", run_negprot_nowait, 0},
8792         {"NBENCH",  run_nbench, 0},
8793         {"NBENCH2", run_nbench2, 0},
8794         {"OPLOCK1",  run_oplock1, 0},
8795         {"OPLOCK2",  run_oplock2, 0},
8796         {"OPLOCK4",  run_oplock4, 0},
8797         {"DIR",  run_dirtest, 0},
8798         {"DIR1",  run_dirtest1, 0},
8799         {"DIR-CREATETIME",  run_dir_createtime, 0},
8800         {"DENY1",  torture_denytest1, 0},
8801         {"DENY2",  torture_denytest2, 0},
8802         {"TCON",  run_tcon_test, 0},
8803         {"TCONDEV",  run_tcon_devtype_test, 0},
8804         {"RW1",  run_readwritetest, 0},
8805         {"RW2",  run_readwritemulti, FLAG_MULTIPROC},
8806         {"RW3",  run_readwritelarge, 0},
8807         {"RW-SIGNING",  run_readwritelarge_signtest, 0},
8808         {"OPEN", run_opentest, 0},
8809         {"POSIX", run_simple_posix_open_test, 0},
8810         {"POSIX-APPEND", run_posix_append, 0},
8811         {"CASE-INSENSITIVE-CREATE", run_case_insensitive_create, 0},
8812         {"ASYNC-ECHO", run_async_echo, 0},
8813         { "UID-REGRESSION-TEST", run_uid_regression_test, 0},
8814         { "SHORTNAME-TEST", run_shortname_test, 0},
8815         { "ADDRCHANGE", run_addrchange, 0},
8816 #if 1
8817         {"OPENATTR", run_openattrtest, 0},
8818 #endif
8819         {"XCOPY", run_xcopy, 0},
8820         {"RENAME", run_rename, 0},
8821         {"DELETE", run_deletetest, 0},
8822         {"DELETE-LN", run_deletetest_ln, 0},
8823         {"PROPERTIES", run_properties, 0},
8824         {"MANGLE", torture_mangle, 0},
8825         {"MANGLE1", run_mangle1, 0},
8826         {"W2K", run_w2ktest, 0},
8827         {"TRANS2SCAN", torture_trans2_scan, 0},
8828         {"NTTRANSSCAN", torture_nttrans_scan, 0},
8829         {"UTABLE", torture_utable, 0},
8830         {"CASETABLE", torture_casetable, 0},
8831         {"ERRMAPEXTRACT", run_error_map_extract, 0},
8832         {"PIPE_NUMBER", run_pipe_number, 0},
8833         {"TCON2",  run_tcon2_test, 0},
8834         {"IOCTL",  torture_ioctl_test, 0},
8835         {"CHKPATH",  torture_chkpath_test, 0},
8836         {"FDSESS", run_fdsesstest, 0},
8837         { "EATEST", run_eatest, 0},
8838         { "SESSSETUP_BENCH", run_sesssetup_bench, 0},
8839         { "CHAIN1", run_chain1, 0},
8840         { "CHAIN2", run_chain2, 0},
8841         { "WINDOWS-WRITE", run_windows_write, 0},
8842         { "NTTRANS-CREATE", run_nttrans_create, 0},
8843         { "CLI_ECHO", run_cli_echo, 0},
8844         { "GETADDRINFO", run_getaddrinfo_send, 0},
8845         { "TLDAP", run_tldap },
8846         { "STREAMERROR", run_streamerror },
8847         { "NOTIFY-BENCH", run_notify_bench },
8848         { "BAD-NBT-SESSION", run_bad_nbt_session },
8849         { "SMB-ANY-CONNECT", run_smb_any_connect },
8850         { "NOTIFY-ONLINE", run_notify_online },
8851         { "SMB2-BASIC", run_smb2_basic },
8852         { "LOCAL-SUBSTITUTE", run_local_substitute, 0},
8853         { "LOCAL-GENCACHE", run_local_gencache, 0},
8854         { "LOCAL-TALLOC-DICT", run_local_talloc_dict, 0},
8855         { "LOCAL-BASE64", run_local_base64, 0},
8856         { "LOCAL-RBTREE", run_local_rbtree, 0},
8857         { "LOCAL-MEMCACHE", run_local_memcache, 0},
8858         { "LOCAL-STREAM-NAME", run_local_stream_name, 0},
8859         { "LOCAL-WBCLIENT", run_local_wbclient, 0},
8860         { "LOCAL-string_to_sid", run_local_string_to_sid, 0},
8861         { "LOCAL-binary_to_sid", run_local_binary_to_sid, 0},
8862         { "LOCAL-DBTRANS", run_local_dbtrans, 0},
8863         { "LOCAL-TEVENT-SELECT", run_local_tevent_select, 0},
8864         { "LOCAL-CONVERT-STRING", run_local_convert_string, 0},
8865         {NULL, NULL, 0}};
8866
8867
8868
8869 /****************************************************************************
8870 run a specified test or "ALL"
8871 ****************************************************************************/
8872 static bool run_test(const char *name)
8873 {
8874         bool ret = True;
8875         bool result = True;
8876         bool found = False;
8877         int i;
8878         double t;
8879         if (strequal(name,"ALL")) {
8880                 for (i=0;torture_ops[i].name;i++) {
8881                         run_test(torture_ops[i].name);
8882                 }
8883                 found = True;
8884         }
8885
8886         for (i=0;torture_ops[i].name;i++) {
8887                 fstr_sprintf(randomfname, "\\XX%x",
8888                          (unsigned)random());
8889
8890                 if (strequal(name, torture_ops[i].name)) {
8891                         found = True;
8892                         printf("Running %s\n", name);
8893                         if (torture_ops[i].flags & FLAG_MULTIPROC) {
8894                                 t = create_procs(torture_ops[i].fn, &result);
8895                                 if (!result) {
8896                                         ret = False;
8897                                         printf("TEST %s FAILED!\n", name);
8898                                 }
8899                         } else {
8900                                 struct timeval start;
8901                                 start = timeval_current();
8902                                 if (!torture_ops[i].fn(0)) {
8903                                         ret = False;
8904                                         printf("TEST %s FAILED!\n", name);
8905                                 }
8906                                 t = timeval_elapsed(&start);
8907                         }
8908                         printf("%s took %g secs\n\n", name, t);
8909                 }
8910         }
8911
8912         if (!found) {
8913                 printf("Did not find a test named %s\n", name);
8914                 ret = False;
8915         }
8916
8917         return ret;
8918 }
8919
8920
8921 static void usage(void)
8922 {
8923         int i;
8924
8925         printf("WARNING samba4 test suite is much more complete nowadays.\n");
8926         printf("Please use samba4 torture.\n\n");
8927
8928         printf("Usage: smbtorture //server/share <options> TEST1 TEST2 ...\n");
8929
8930         printf("\t-d debuglevel\n");
8931         printf("\t-U user%%pass\n");
8932         printf("\t-k               use kerberos\n");
8933         printf("\t-N numprocs\n");
8934         printf("\t-n my_netbios_name\n");
8935         printf("\t-W workgroup\n");
8936         printf("\t-o num_operations\n");
8937         printf("\t-O socket_options\n");
8938         printf("\t-m maximum protocol\n");
8939         printf("\t-L use oplocks\n");
8940         printf("\t-c CLIENT.TXT   specify client load file for NBENCH\n");
8941         printf("\t-A showall\n");
8942         printf("\t-p port\n");
8943         printf("\t-s seed\n");
8944         printf("\t-b unclist_filename   specify multiple shares for multiple connections\n");
8945         printf("\t-f filename   filename to test\n");
8946         printf("\n\n");
8947
8948         printf("tests are:");
8949         for (i=0;torture_ops[i].name;i++) {
8950                 printf(" %s", torture_ops[i].name);
8951         }
8952         printf("\n");
8953
8954         printf("default test is ALL\n");
8955
8956         exit(1);
8957 }
8958
8959 /****************************************************************************
8960   main program
8961 ****************************************************************************/
8962  int main(int argc,char *argv[])
8963 {
8964         int opt, i;
8965         char *p;
8966         int gotuser = 0;
8967         int gotpass = 0;
8968         bool correct = True;
8969         TALLOC_CTX *frame = talloc_stackframe();
8970         int seed = time(NULL);
8971
8972 #ifdef HAVE_SETBUFFER
8973         setbuffer(stdout, NULL, 0);
8974 #endif
8975
8976         setup_logging("smbtorture", DEBUG_STDOUT);
8977
8978         load_case_tables();
8979
8980         if (is_default_dyn_CONFIGFILE()) {
8981                 if(getenv("SMB_CONF_PATH")) {
8982                         set_dyn_CONFIGFILE(getenv("SMB_CONF_PATH"));
8983                 }
8984         }
8985         lp_load_global(get_dyn_CONFIGFILE());
8986         load_interfaces();
8987
8988         if (argc < 2) {
8989                 usage();
8990         }
8991
8992         for(p = argv[1]; *p; p++)
8993           if(*p == '\\')
8994             *p = '/';
8995
8996         if (strncmp(argv[1], "//", 2)) {
8997                 usage();
8998         }
8999
9000         fstrcpy(host, &argv[1][2]);
9001         p = strchr_m(&host[2],'/');
9002         if (!p) {
9003                 usage();
9004         }
9005         *p = 0;
9006         fstrcpy(share, p+1);
9007
9008         fstrcpy(myname, get_myname(talloc_tos()));
9009         if (!*myname) {
9010                 fprintf(stderr, "Failed to get my hostname.\n");
9011                 return 1;
9012         }
9013
9014         if (*username == 0 && getenv("LOGNAME")) {
9015           fstrcpy(username,getenv("LOGNAME"));
9016         }
9017
9018         argc--;
9019         argv++;
9020
9021         fstrcpy(workgroup, lp_workgroup());
9022
9023         while ((opt = getopt(argc, argv, "p:hW:U:n:N:O:o:m:Ll:d:Aec:ks:b:B:f:"))
9024                != EOF) {
9025                 switch (opt) {
9026                 case 'p':
9027                         port_to_use = atoi(optarg);
9028                         break;
9029                 case 's':
9030                         seed = atoi(optarg);
9031                         break;
9032                 case 'W':
9033                         fstrcpy(workgroup,optarg);
9034                         break;
9035                 case 'm':
9036                         max_protocol = interpret_protocol(optarg, max_protocol);
9037                         break;
9038                 case 'N':
9039                         nprocs = atoi(optarg);
9040                         break;
9041                 case 'o':
9042                         torture_numops = atoi(optarg);
9043                         break;
9044                 case 'd':
9045                         lp_set_cmdline("log level", optarg);
9046                         break;
9047                 case 'O':
9048                         sockops = optarg;
9049                         break;
9050                 case 'L':
9051                         use_oplocks = True;
9052                         break;
9053                 case 'l':
9054                         local_path = optarg;
9055                         break;
9056                 case 'A':
9057                         torture_showall = True;
9058                         break;
9059                 case 'n':
9060                         fstrcpy(myname, optarg);
9061                         break;
9062                 case 'c':
9063                         client_txt = optarg;
9064                         break;
9065                 case 'e':
9066                         do_encrypt = true;
9067                         break;
9068                 case 'k':
9069 #ifdef HAVE_KRB5
9070                         use_kerberos = True;
9071 #else
9072                         d_printf("No kerberos support compiled in\n");
9073                         exit(1);
9074 #endif
9075                         break;
9076                 case 'U':
9077                         gotuser = 1;
9078                         fstrcpy(username,optarg);
9079                         p = strchr_m(username,'%');
9080                         if (p) {
9081                                 *p = 0;
9082                                 fstrcpy(password, p+1);
9083                                 gotpass = 1;
9084                         }
9085                         break;
9086                 case 'b':
9087                         fstrcpy(multishare_conn_fname, optarg);
9088                         use_multishare_conn = True;
9089                         break;
9090                 case 'B':
9091                         torture_blocksize = atoi(optarg);
9092                         break;
9093                 case 'f':
9094                         test_filename = SMB_STRDUP(optarg);
9095                         break;
9096                 default:
9097                         printf("Unknown option %c (%d)\n", (char)opt, opt);
9098                         usage();
9099                 }
9100         }
9101
9102         d_printf("using seed %d\n", seed);
9103
9104         srandom(seed);
9105
9106         if(use_kerberos && !gotuser) gotpass = True;
9107
9108         while (!gotpass) {
9109                 p = getpass("Password:");
9110                 if (p) {
9111                         fstrcpy(password, p);
9112                         gotpass = 1;
9113                 }
9114         }
9115
9116         printf("host=%s share=%s user=%s myname=%s\n",
9117                host, share, username, myname);
9118
9119         if (argc == optind) {
9120                 correct = run_test("ALL");
9121         } else {
9122                 for (i=optind;i<argc;i++) {
9123                         if (!run_test(argv[i])) {
9124                                 correct = False;
9125                         }
9126                 }
9127         }
9128
9129         TALLOC_FREE(frame);
9130
9131         if (correct) {
9132                 return(0);
9133         } else {
9134                 return(1);
9135         }
9136 }