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