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