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