source3/torture/torture.c

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