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