source3/torture/torture.c

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