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         status = cli_nt_delete_on_close(cli1, fnum1, true);
4147         if (!NT_STATUS_IS_OK(status)) {
4148                 printf("[7] setting delete_on_close on file failed !\n");
4149                 correct = False;
4150                 goto fail;
4151         }
4152
4153         status = cli_nt_delete_on_close(cli1, fnum1, false);
4154         if (!NT_STATUS_IS_OK(status)) {
4155                 printf("[7] unsetting delete_on_close on file failed !\n");
4156                 correct = False;
4157                 goto fail;
4158         }
4159
4160         status = cli_close(cli1, fnum1);
4161         if (!NT_STATUS_IS_OK(status)) {
4162                 printf("[7] close - 2 failed (%s)\n", nt_errstr(status));
4163                 correct = False;
4164                 goto fail;
4165         }
4166
4167         /* This next open should succeed - we reset the flag. */
4168         status = cli_openx(cli1, fname, O_RDONLY, DENY_NONE, &fnum1);
4169         if (!NT_STATUS_IS_OK(status)) {
4170                 printf("[5] open of %s failed (%s)\n", fname, nt_errstr(status));
4171                 correct = False;
4172                 goto fail;
4173         }
4174
4175         status = cli_close(cli1, fnum1);
4176         if (!NT_STATUS_IS_OK(status)) {
4177                 printf("[7] close - 2 failed (%s)\n", nt_errstr(status));
4178                 correct = False;
4179                 goto fail;
4180         }
4181
4182         printf("seventh delete on close test succeeded.\n");
4183
4184         /* Test 7 ... */
4185         cli_setatr(cli1, fname, 0, 0);
4186         cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4187
4188         if (!torture_open_connection(&cli2, 1)) {
4189                 printf("[8] failed to open second connection.\n");
4190                 correct = False;
4191                 goto fail;
4192         }
4193
4194         smbXcli_conn_set_sockopt(cli1->conn, sockops);
4195
4196         status = cli_ntcreate(cli1, fname, 0,
4197                              FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
4198                              FILE_ATTRIBUTE_NORMAL,
4199                              FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
4200                              FILE_OVERWRITE_IF, 0, 0, &fnum1);
4201         if (!NT_STATUS_IS_OK(status)) {
4202                 printf("[8] open 1 of %s failed (%s)\n", fname, nt_errstr(status));
4203                 correct = False;
4204                 goto fail;
4205         }
4206
4207         status = cli_ntcreate(cli2, fname, 0,
4208                              FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
4209                              FILE_ATTRIBUTE_NORMAL,
4210                              FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
4211                              FILE_OPEN, 0, 0, &fnum2);
4212         if (!NT_STATUS_IS_OK(status)) {
4213                 printf("[8] open 2 of %s failed (%s)\n", fname, nt_errstr(status));
4214                 correct = False;
4215                 goto fail;
4216         }
4217
4218         status = cli_nt_delete_on_close(cli1, fnum1, true);
4219         if (!NT_STATUS_IS_OK(status)) {
4220                 printf("[8] setting delete_on_close on file failed !\n");
4221                 correct = False;
4222                 goto fail;
4223         }
4224
4225         status = cli_close(cli1, fnum1);
4226         if (!NT_STATUS_IS_OK(status)) {
4227                 printf("[8] close - 1 failed (%s)\n", nt_errstr(status));
4228                 correct = False;
4229                 goto fail;
4230         }
4231
4232         status = cli_close(cli2, fnum2);
4233         if (!NT_STATUS_IS_OK(status)) {
4234                 printf("[8] close - 2 failed (%s)\n", nt_errstr(status));
4235                 correct = False;
4236                 goto fail;
4237         }
4238
4239         /* This should fail.. */
4240         status = cli_openx(cli1, fname, O_RDONLY, DENY_NONE, &fnum1);
4241         if (NT_STATUS_IS_OK(status)) {
4242                 printf("[8] open of %s succeeded should have been deleted on close !\n", fname);
4243                 goto fail;
4244                 correct = False;
4245         } else
4246                 printf("eighth delete on close test succeeded.\n");
4247
4248         /* This should fail - we need to set DELETE_ACCESS. */
4249         status = cli_ntcreate(cli1, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA,
4250                               FILE_ATTRIBUTE_NORMAL,
4251                               FILE_SHARE_NONE,
4252                               FILE_OVERWRITE_IF,
4253                               FILE_DELETE_ON_CLOSE, 0, &fnum1);
4254         if (NT_STATUS_IS_OK(status)) {
4255                 printf("[9] open of %s succeeded should have failed!\n", fname);
4256                 correct = False;
4257                 goto fail;
4258         }
4259
4260         printf("ninth delete on close test succeeded.\n");
4261
4262         status = cli_ntcreate(cli1, fname, 0,
4263                              FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
4264                              FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE,
4265                              FILE_OVERWRITE_IF, FILE_DELETE_ON_CLOSE,
4266                              0, &fnum1);
4267         if (!NT_STATUS_IS_OK(status)) {
4268                 printf("[10] open of %s failed (%s)\n", fname, nt_errstr(status));
4269                 correct = False;
4270                 goto fail;
4271         }
4272
4273         /* This should delete the file. */
4274         status = cli_close(cli1, fnum1);
4275         if (!NT_STATUS_IS_OK(status)) {
4276                 printf("[10] close failed (%s)\n", nt_errstr(status));
4277                 correct = False;
4278                 goto fail;
4279         }
4280
4281         /* This should fail.. */
4282         if (NT_STATUS_IS_OK(cli_openx(cli1, fname, O_RDONLY, DENY_NONE, &fnum1))) {
4283                 printf("[10] open of %s succeeded should have been deleted on close !\n", fname);
4284                 goto fail;
4285                 correct = False;
4286         } else
4287                 printf("tenth delete on close test succeeded.\n");
4288
4289         cli_setatr(cli1, fname, 0, 0);
4290         cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4291
4292         /* What error do we get when attempting to open a read-only file with
4293            delete access ? */
4294
4295         /* Create a readonly file. */
4296         status = cli_ntcreate(cli1, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA,
4297                               FILE_ATTRIBUTE_READONLY, FILE_SHARE_NONE,
4298                               FILE_OVERWRITE_IF, 0, 0, &fnum1);
4299         if (!NT_STATUS_IS_OK(status)) {
4300                 printf("[11] open of %s failed (%s)\n", fname, nt_errstr(status));
4301                 correct = False;
4302                 goto fail;
4303         }
4304
4305         status = cli_close(cli1, fnum1);
4306         if (!NT_STATUS_IS_OK(status)) {
4307                 printf("[11] close failed (%s)\n", nt_errstr(status));
4308                 correct = False;
4309                 goto fail;
4310         }
4311
4312         /* Now try open for delete access. */
4313         status = cli_ntcreate(cli1, fname, 0,
4314                              FILE_READ_ATTRIBUTES|DELETE_ACCESS,
4315                              0,
4316                              FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
4317                              FILE_OVERWRITE_IF, 0, 0, &fnum1);
4318         if (NT_STATUS_IS_OK(status)) {
4319                 printf("[11] open of %s succeeded should have been denied with ACCESS_DENIED!\n", fname);
4320                 cli_close(cli1, fnum1);
4321                 goto fail;
4322                 correct = False;
4323         } else {
4324                 if (!NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED)) {
4325                         printf("[11] open of %s should have been denied with ACCESS_DENIED! Got error %s\n", fname, nt_errstr(status));
4326                         goto fail;
4327                         correct = False;
4328                 } else {
4329                         printf("eleventh delete on close test succeeded.\n");
4330                 }
4331         }
4332
4333         printf("finished delete test\n");
4334
4335   fail:
4336         /* FIXME: This will crash if we aborted before cli2 got
4337          * intialized, because these functions don't handle
4338          * uninitialized connections. */
4339
4340         if (fnum1 != (uint16_t)-1) cli_close(cli1, fnum1);
4341         if (fnum2 != (uint16_t)-1) cli_close(cli1, fnum2);
4342         cli_setatr(cli1, fname, 0, 0);
4343         cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4344
4345         if (cli1 && !torture_close_connection(cli1)) {
4346                 correct = False;
4347         }
4348         if (cli2 && !torture_close_connection(cli2)) {
4349                 correct = False;
4350         }
4351         return correct;
4352 }
4353
4354 static bool run_deletetest_ln(int dummy)
4355 {
4356         struct cli_state *cli;
4357         const char *fname = "\\delete1";
4358         const char *fname_ln = "\\delete1_ln";
4359         uint16_t fnum;
4360         uint16_t fnum1;
4361         NTSTATUS status;
4362         bool correct = true;
4363         time_t t;
4364
4365         printf("starting deletetest-ln\n");
4366
4367         if (!torture_open_connection(&cli, 0)) {
4368                 return false;
4369         }
4370
4371         cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4372         cli_unlink(cli, fname_ln, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4373
4374         smbXcli_conn_set_sockopt(cli->conn, sockops);
4375
4376         /* Create the file. */
4377         status = cli_openx(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum);
4378         if (!NT_STATUS_IS_OK(status)) {
4379                 printf("open of %s failed (%s)\n", fname, nt_errstr(status));
4380                 return false;
4381         }
4382
4383         status = cli_close(cli, fnum);
4384         if (!NT_STATUS_IS_OK(status)) {
4385                 printf("close1 failed (%s)\n", nt_errstr(status));
4386                 return false;
4387         }
4388
4389         /* Now create a hardlink. */
4390         status = cli_nt_hardlink(cli, fname, fname_ln);
4391         if (!NT_STATUS_IS_OK(status)) {
4392                 printf("nt hardlink failed (%s)\n", nt_errstr(status));
4393                 return false;
4394         }
4395
4396         /* Open the original file. */
4397         status = cli_ntcreate(cli, fname, 0, FILE_READ_DATA,
4398                         FILE_ATTRIBUTE_NORMAL,
4399                         FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
4400                         FILE_OPEN_IF, 0, 0, &fnum);
4401         if (!NT_STATUS_IS_OK(status)) {
4402                 printf("ntcreate of %s failed (%s)\n", fname, nt_errstr(status));
4403                 return false;
4404         }
4405
4406         /* Unlink the hard link path. */
4407         status = cli_ntcreate(cli, fname_ln, 0, DELETE_ACCESS,
4408                         FILE_ATTRIBUTE_NORMAL,
4409                         FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
4410                         FILE_OPEN_IF, 0, 0, &fnum1);
4411         if (!NT_STATUS_IS_OK(status)) {
4412                 printf("ntcreate of %s failed (%s)\n", fname_ln, nt_errstr(status));
4413                 return false;
4414         }
4415         status = cli_nt_delete_on_close(cli, fnum1, true);
4416         if (!NT_STATUS_IS_OK(status)) {
4417                 d_printf("(%s) failed to set delete_on_close %s: %s\n",
4418                         __location__, fname_ln, nt_errstr(status));
4419                 return false;
4420         }
4421
4422         status = cli_close(cli, fnum1);
4423         if (!NT_STATUS_IS_OK(status)) {
4424                 printf("close %s failed (%s)\n",
4425                         fname_ln, nt_errstr(status));
4426                 return false;
4427         }
4428
4429         status = cli_close(cli, fnum);
4430         if (!NT_STATUS_IS_OK(status)) {
4431                 printf("close %s failed (%s)\n",
4432                         fname, nt_errstr(status));
4433                 return false;
4434         }
4435
4436         /* Ensure the original file is still there. */
4437         status = cli_getatr(cli, fname, NULL, NULL, &t);
4438         if (!NT_STATUS_IS_OK(status)) {
4439                 printf("%s getatr on file %s failed (%s)\n",
4440                         __location__,
4441                         fname,
4442                         nt_errstr(status));
4443                 correct = False;
4444         }
4445
4446         /* Ensure the link path is gone. */
4447         status = cli_getatr(cli, fname_ln, NULL, NULL, &t);
4448         if (!NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
4449                 printf("%s, getatr for file %s returned wrong error code %s "
4450                         "- should have been deleted\n",
4451                         __location__,
4452                         fname_ln, nt_errstr(status));
4453                 correct = False;
4454         }
4455
4456         cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4457         cli_unlink(cli, fname_ln, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4458
4459         if (!torture_close_connection(cli)) {
4460                 correct = false;
4461         }
4462
4463         printf("finished deletetest-ln\n");
4464
4465         return correct;
4466 }
4467
4468 /*
4469   print out server properties
4470  */
4471 static bool run_properties(int dummy)
4472 {
4473         struct cli_state *cli;
4474         bool correct = True;
4475
4476         printf("starting properties test\n");
4477
4478         ZERO_STRUCT(cli);
4479
4480         if (!torture_open_connection(&cli, 0)) {
4481                 return False;
4482         }
4483
4484         smbXcli_conn_set_sockopt(cli->conn, sockops);
4485
4486         d_printf("Capabilities 0x%08x\n", smb1cli_conn_capabilities(cli->conn));
4487
4488         if (!torture_close_connection(cli)) {
4489                 correct = False;
4490         }
4491
4492         return correct;
4493 }
4494
4495
4496
4497 /* FIRST_DESIRED_ACCESS   0xf019f */
4498 #define FIRST_DESIRED_ACCESS   FILE_READ_DATA|FILE_WRITE_DATA|FILE_APPEND_DATA|\
4499                                FILE_READ_EA|                           /* 0xf */ \
4500                                FILE_WRITE_EA|FILE_READ_ATTRIBUTES|     /* 0x90 */ \
4501                                FILE_WRITE_ATTRIBUTES|                  /* 0x100 */ \
4502                                DELETE_ACCESS|READ_CONTROL_ACCESS|\
4503                                WRITE_DAC_ACCESS|WRITE_OWNER_ACCESS     /* 0xf0000 */
4504 /* SECOND_DESIRED_ACCESS  0xe0080 */
4505 #define SECOND_DESIRED_ACCESS  FILE_READ_ATTRIBUTES|                   /* 0x80 */ \
4506                                READ_CONTROL_ACCESS|WRITE_DAC_ACCESS|\
4507                                WRITE_OWNER_ACCESS                      /* 0xe0000 */
4508
4509 #if 0
4510 #define THIRD_DESIRED_ACCESS   FILE_READ_ATTRIBUTES|                   /* 0x80 */ \
4511                                READ_CONTROL_ACCESS|WRITE_DAC_ACCESS|\
4512                                FILE_READ_DATA|\
4513                                WRITE_OWNER_ACCESS                      /* */
4514 #endif
4515
4516 /*
4517   Test ntcreate calls made by xcopy
4518  */
4519 static bool run_xcopy(int dummy)
4520 {
4521         static struct cli_state *cli1;
4522         const char *fname = "\\test.txt";
4523         bool correct = True;
4524         uint16_t fnum1, fnum2;
4525         NTSTATUS status;
4526
4527         printf("starting xcopy test\n");
4528
4529         if (!torture_open_connection(&cli1, 0)) {
4530                 return False;
4531         }
4532
4533         status = cli_ntcreate(cli1, fname, 0, FIRST_DESIRED_ACCESS,
4534                               FILE_ATTRIBUTE_ARCHIVE, FILE_SHARE_NONE,
4535                               FILE_OVERWRITE_IF, 0x4044, 0, &fnum1);
4536         if (!NT_STATUS_IS_OK(status)) {
4537                 printf("First open failed - %s\n", nt_errstr(status));
4538                 return False;
4539         }
4540
4541         status = cli_ntcreate(cli1, fname, 0, SECOND_DESIRED_ACCESS, 0,
4542                              FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
4543                              FILE_OPEN, 0x200000, 0, &fnum2);
4544         if (!NT_STATUS_IS_OK(status)) {
4545                 printf("second open failed - %s\n", nt_errstr(status));
4546                 return False;
4547         }
4548
4549         if (!torture_close_connection(cli1)) {
4550                 correct = False;
4551         }
4552
4553         return correct;
4554 }
4555
4556 /*
4557   Test rename on files open with share delete and no share delete.
4558  */
4559 static bool run_rename(int dummy)
4560 {
4561         static struct cli_state *cli1;
4562         const char *fname = "\\test.txt";
4563         const char *fname1 = "\\test1.txt";
4564         bool correct = True;
4565         uint16_t fnum1;
4566         uint16_t attr;
4567         NTSTATUS status;
4568
4569         printf("starting rename test\n");
4570
4571         if (!torture_open_connection(&cli1, 0)) {
4572                 return False;
4573         }
4574
4575         cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4576         cli_unlink(cli1, fname1, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4577
4578         status = cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS,
4579                               FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ,
4580                               FILE_OVERWRITE_IF, 0, 0, &fnum1);
4581         if (!NT_STATUS_IS_OK(status)) {
4582                 printf("First open failed - %s\n", nt_errstr(status));
4583                 return False;
4584         }
4585
4586         status = cli_rename(cli1, fname, fname1);
4587         if (!NT_STATUS_IS_OK(status)) {
4588                 printf("First rename failed (SHARE_READ) (this is correct) - %s\n", nt_errstr(status));
4589         } else {
4590                 printf("First rename succeeded (SHARE_READ) - this should have failed !\n");
4591                 correct = False;
4592         }
4593
4594         status = cli_close(cli1, fnum1);
4595         if (!NT_STATUS_IS_OK(status)) {
4596                 printf("close - 1 failed (%s)\n", nt_errstr(status));
4597                 return False;
4598         }
4599
4600         cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4601         cli_unlink(cli1, fname1, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4602         status = cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS, FILE_ATTRIBUTE_NORMAL,
4603 #if 0
4604                               FILE_SHARE_DELETE|FILE_SHARE_NONE,
4605 #else
4606                               FILE_SHARE_DELETE|FILE_SHARE_READ,
4607 #endif
4608                               FILE_OVERWRITE_IF, 0, 0, &fnum1);
4609         if (!NT_STATUS_IS_OK(status)) {
4610                 printf("Second open failed - %s\n", nt_errstr(status));
4611                 return False;
4612         }
4613
4614         status = cli_rename(cli1, fname, fname1);
4615         if (!NT_STATUS_IS_OK(status)) {
4616                 printf("Second rename failed (SHARE_DELETE | SHARE_READ) - this should have succeeded - %s\n", nt_errstr(status));
4617                 correct = False;
4618         } else {
4619                 printf("Second rename succeeded (SHARE_DELETE | SHARE_READ)\n");
4620         }
4621
4622         status = cli_close(cli1, fnum1);
4623         if (!NT_STATUS_IS_OK(status)) {
4624                 printf("close - 2 failed (%s)\n", nt_errstr(status));
4625                 return False;
4626         }
4627
4628         cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4629         cli_unlink(cli1, fname1, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4630
4631         status = cli_ntcreate(cli1, fname, 0, READ_CONTROL_ACCESS,
4632                               FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE,
4633                               FILE_OVERWRITE_IF, 0, 0, &fnum1);
4634         if (!NT_STATUS_IS_OK(status)) {
4635                 printf("Third open failed - %s\n", nt_errstr(status));
4636                 return False;
4637         }
4638
4639
4640 #if 0
4641   {
4642         uint16_t fnum2;
4643
4644         if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, DELETE_ACCESS, FILE_ATTRIBUTE_NORMAL,
4645                                    FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0, &fnum2))) {
4646                 printf("Fourth open failed - %s\n", cli_errstr(cli1));
4647                 return False;
4648         }
4649         if (!NT_STATUS_IS_OK(cli_nt_delete_on_close(cli1, fnum2, true))) {
4650                 printf("[8] setting delete_on_close on file failed !\n");
4651                 return False;
4652         }
4653
4654         if (!NT_STATUS_IS_OK(cli_close(cli1, fnum2))) {
4655                 printf("close - 4 failed (%s)\n", cli_errstr(cli1));
4656                 return False;
4657         }
4658   }
4659 #endif
4660
4661         status = cli_rename(cli1, fname, fname1);
4662         if (!NT_STATUS_IS_OK(status)) {
4663                 printf("Third rename failed (SHARE_NONE) - this should have succeeded - %s\n", nt_errstr(status));
4664                 correct = False;
4665         } else {
4666                 printf("Third rename succeeded (SHARE_NONE)\n");
4667         }
4668
4669         status = cli_close(cli1, fnum1);
4670         if (!NT_STATUS_IS_OK(status)) {
4671                 printf("close - 3 failed (%s)\n", nt_errstr(status));
4672                 return False;
4673         }
4674
4675         cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4676         cli_unlink(cli1, fname1, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4677
4678         /*----*/
4679
4680         status = cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS,
4681                               FILE_ATTRIBUTE_NORMAL,
4682                               FILE_SHARE_READ | FILE_SHARE_WRITE,
4683                               FILE_OVERWRITE_IF, 0, 0, &fnum1);
4684         if (!NT_STATUS_IS_OK(status)) {
4685                 printf("Fourth open failed - %s\n", nt_errstr(status));
4686                 return False;
4687         }
4688
4689         status = cli_rename(cli1, fname, fname1);
4690         if (!NT_STATUS_IS_OK(status)) {
4691                 printf("Fourth rename failed (SHARE_READ | SHARE_WRITE) (this is correct) - %s\n", nt_errstr(status));
4692         } else {
4693                 printf("Fourth rename succeeded (SHARE_READ | SHARE_WRITE) - this should have failed !\n");
4694                 correct = False;
4695         }
4696
4697         status = cli_close(cli1, fnum1);
4698         if (!NT_STATUS_IS_OK(status)) {
4699                 printf("close - 4 failed (%s)\n", nt_errstr(status));
4700                 return False;
4701         }
4702
4703         cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4704         cli_unlink(cli1, fname1, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4705
4706         /*--*/
4707
4708         status = cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS,
4709                          FILE_ATTRIBUTE_NORMAL,
4710                          FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
4711                          FILE_OVERWRITE_IF, 0, 0, &fnum1);
4712         if (!NT_STATUS_IS_OK(status)) {
4713                 printf("Fifth open failed - %s\n", nt_errstr(status));
4714                 return False;
4715         }
4716
4717         status = cli_rename(cli1, fname, fname1);
4718         if (!NT_STATUS_IS_OK(status)) {
4719                 printf("Fifth rename failed (SHARE_READ | SHARE_WRITE | SHARE_DELETE) - this should have succeeded - %s ! \n", nt_errstr(status));
4720                 correct = False;
4721         } else {
4722                 printf("Fifth rename succeeded (SHARE_READ | SHARE_WRITE | SHARE_DELETE) (this is correct) - %s\n", nt_errstr(status));
4723         }
4724
4725         /*
4726          * Now check if the first name still exists ...
4727          */
4728
4729         /* if (!NT_STATUS_OP(cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS, FILE_ATTRIBUTE_NORMAL,
4730                                    FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, FILE_OVERWRITE_IF, 0, 0, &fnum2))) {
4731           printf("Opening original file after rename of open file fails: %s\n",
4732               cli_errstr(cli1));
4733         }
4734         else {
4735           printf("Opening original file after rename of open file works ...\n");
4736           (void)cli_close(cli1, fnum2);
4737           } */
4738
4739         /*--*/
4740         status = cli_close(cli1, fnum1);
4741         if (!NT_STATUS_IS_OK(status)) {
4742                 printf("close - 5 failed (%s)\n", nt_errstr(status));
4743                 return False;
4744         }
4745
4746         /* Check that the renamed file has FILE_ATTRIBUTE_ARCHIVE. */
4747         status = cli_getatr(cli1, fname1, &attr, NULL, NULL);
4748         if (!NT_STATUS_IS_OK(status)) {
4749                 printf("getatr on file %s failed - %s ! \n",
4750                         fname1, nt_errstr(status));
4751                 correct = False;
4752         } else {
4753                 if (attr != FILE_ATTRIBUTE_ARCHIVE) {
4754                         printf("Renamed file %s has wrong attr 0x%x "
4755                                 "(should be 0x%x)\n",
4756                                 fname1,
4757                                 attr,
4758                                 (unsigned int)FILE_ATTRIBUTE_ARCHIVE);
4759                         correct = False;
4760                 } else {
4761                         printf("Renamed file %s has archive bit set\n", fname1);
4762                 }
4763         }
4764
4765         cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4766         cli_unlink(cli1, fname1, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4767
4768         if (!torture_close_connection(cli1)) {
4769                 correct = False;
4770         }
4771
4772         return correct;
4773 }
4774
4775 static bool run_pipe_number(int dummy)
4776 {
4777         struct cli_state *cli1;
4778         const char *pipe_name = "\\SPOOLSS";
4779         uint16_t fnum;
4780         int num_pipes = 0;
4781         NTSTATUS status;
4782
4783         printf("starting pipenumber test\n");
4784         if (!torture_open_connection(&cli1, 0)) {
4785                 return False;
4786         }
4787
4788         smbXcli_conn_set_sockopt(cli1->conn, sockops);
4789         while(1) {
4790                 status = cli_ntcreate(cli1, pipe_name, 0, FILE_READ_DATA,
4791                                       FILE_ATTRIBUTE_NORMAL,
4792                                       FILE_SHARE_READ|FILE_SHARE_WRITE,
4793                                       FILE_OPEN_IF, 0, 0, &fnum);
4794                 if (!NT_STATUS_IS_OK(status)) {
4795                         printf("Open of pipe %s failed with error (%s)\n", pipe_name, nt_errstr(status));
4796                         break;
4797                 }
4798                 num_pipes++;
4799                 printf("\r%6d", num_pipes);
4800         }
4801
4802         printf("pipe_number test - we can open %d %s pipes.\n", num_pipes, pipe_name );
4803         torture_close_connection(cli1);
4804         return True;
4805 }
4806
4807 /*
4808   Test open mode returns on read-only files.
4809  */
4810 static bool run_opentest(int dummy)
4811 {
4812         static struct cli_state *cli1;
4813         static struct cli_state *cli2;
4814         const char *fname = "\\readonly.file";
4815         uint16_t fnum1, fnum2;
4816         char buf[20];
4817         off_t fsize;
4818         bool correct = True;
4819         char *tmp_path;
4820         NTSTATUS status;
4821
4822         printf("starting open test\n");
4823
4824         if (!torture_open_connection(&cli1, 0)) {
4825                 return False;
4826         }
4827
4828         cli_setatr(cli1, fname, 0, 0);
4829         cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4830
4831         smbXcli_conn_set_sockopt(cli1->conn, sockops);
4832
4833         status = cli_openx(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1);
4834         if (!NT_STATUS_IS_OK(status)) {
4835                 printf("open of %s failed (%s)\n", fname, nt_errstr(status));
4836                 return False;
4837         }
4838
4839         status = cli_close(cli1, fnum1);
4840         if (!NT_STATUS_IS_OK(status)) {
4841                 printf("close2 failed (%s)\n", nt_errstr(status));
4842                 return False;
4843         }
4844
4845         status = cli_setatr(cli1, fname, FILE_ATTRIBUTE_READONLY, 0);
4846         if (!NT_STATUS_IS_OK(status)) {
4847                 printf("cli_setatr failed (%s)\n", nt_errstr(status));
4848                 return False;
4849         }
4850
4851         status = cli_openx(cli1, fname, O_RDONLY, DENY_WRITE, &fnum1);
4852         if (!NT_STATUS_IS_OK(status)) {
4853                 printf("open of %s failed (%s)\n", fname, nt_errstr(status));
4854                 return False;
4855         }
4856
4857         /* This will fail - but the error should be ERRnoaccess, not ERRbadshare. */
4858         status = cli_openx(cli1, fname, O_RDWR, DENY_ALL, &fnum2);
4859
4860         if (check_error(__LINE__, status, ERRDOS, ERRnoaccess,
4861                         NT_STATUS_ACCESS_DENIED)) {
4862                 printf("correct error code ERRDOS/ERRnoaccess returned\n");
4863         }
4864
4865         printf("finished open test 1\n");
4866
4867         cli_close(cli1, fnum1);
4868
4869         /* Now try not readonly and ensure ERRbadshare is returned. */
4870
4871         cli_setatr(cli1, fname, 0, 0);
4872
4873         status = cli_openx(cli1, fname, O_RDONLY, DENY_WRITE, &fnum1);
4874         if (!NT_STATUS_IS_OK(status)) {
4875                 printf("open of %s failed (%s)\n", fname, nt_errstr(status));
4876                 return False;
4877         }
4878
4879         /* This will fail - but the error should be ERRshare. */
4880         status = cli_openx(cli1, fname, O_RDWR, DENY_ALL, &fnum2);
4881
4882         if (check_error(__LINE__, status, ERRDOS, ERRbadshare,
4883                         NT_STATUS_SHARING_VIOLATION)) {
4884                 printf("correct error code ERRDOS/ERRbadshare returned\n");
4885         }
4886
4887         status = cli_close(cli1, fnum1);
4888         if (!NT_STATUS_IS_OK(status)) {
4889                 printf("close2 failed (%s)\n", nt_errstr(status));
4890                 return False;
4891         }
4892
4893         cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4894
4895         printf("finished open test 2\n");
4896
4897         /* Test truncate open disposition on file opened for read. */
4898         status = cli_openx(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1);
4899         if (!NT_STATUS_IS_OK(status)) {
4900                 printf("(3) open (1) of %s failed (%s)\n", fname, nt_errstr(status));
4901                 return False;
4902         }
4903
4904         /* write 20 bytes. */
4905
4906         memset(buf, '\0', 20);
4907
4908         status = cli_writeall(cli1, fnum1, 0, (uint8_t *)buf, 0, 20, NULL);
4909         if (!NT_STATUS_IS_OK(status)) {
4910                 printf("write failed (%s)\n", nt_errstr(status));
4911                 correct = False;
4912         }
4913
4914         status = cli_close(cli1, fnum1);
4915         if (!NT_STATUS_IS_OK(status)) {
4916                 printf("(3) close1 failed (%s)\n", nt_errstr(status));
4917                 return False;
4918         }
4919
4920         /* Ensure size == 20. */
4921         status = cli_getatr(cli1, fname, NULL, &fsize, NULL);
4922         if (!NT_STATUS_IS_OK(status)) {
4923                 printf("(3) getatr failed (%s)\n", nt_errstr(status));
4924                 return False;
4925         }
4926
4927         if (fsize != 20) {
4928                 printf("(3) file size != 20\n");
4929                 return False;
4930         }
4931
4932         /* Now test if we can truncate a file opened for readonly. */
4933         status = cli_openx(cli1, fname, O_RDONLY|O_TRUNC, DENY_NONE, &fnum1);
4934         if (!NT_STATUS_IS_OK(status)) {
4935                 printf("(3) open (2) of %s failed (%s)\n", fname, nt_errstr(status));
4936                 return False;
4937         }
4938
4939         status = cli_close(cli1, fnum1);
4940         if (!NT_STATUS_IS_OK(status)) {
4941                 printf("close2 failed (%s)\n", nt_errstr(status));
4942                 return False;
4943         }
4944
4945         /* Ensure size == 0. */
4946         status = cli_getatr(cli1, fname, NULL, &fsize, NULL);
4947         if (!NT_STATUS_IS_OK(status)) {
4948                 printf("(3) getatr failed (%s)\n", nt_errstr(status));
4949                 return False;
4950         }
4951
4952         if (fsize != 0) {
4953                 printf("(3) file size != 0\n");
4954                 return False;
4955         }
4956         printf("finished open test 3\n");
4957
4958         cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4959
4960         printf("Do ctemp tests\n");
4961         status = cli_ctemp(cli1, talloc_tos(), "\\", &fnum1, &tmp_path);
4962         if (!NT_STATUS_IS_OK(status)) {
4963                 printf("ctemp failed (%s)\n", nt_errstr(status));
4964                 return False;
4965         }
4966
4967         printf("ctemp gave path %s\n", tmp_path);
4968         status = cli_close(cli1, fnum1);
4969         if (!NT_STATUS_IS_OK(status)) {
4970                 printf("close of temp failed (%s)\n", nt_errstr(status));
4971         }
4972
4973         status = cli_unlink(cli1, tmp_path, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4974         if (!NT_STATUS_IS_OK(status)) {
4975                 printf("unlink of temp failed (%s)\n", nt_errstr(status));
4976         }
4977
4978         /* Test the non-io opens... */
4979
4980         if (!torture_open_connection(&cli2, 1)) {
4981                 return False;
4982         }
4983
4984         cli_setatr(cli2, fname, 0, 0);
4985         cli_unlink(cli2, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
4986
4987         smbXcli_conn_set_sockopt(cli2->conn, sockops);
4988
4989         printf("TEST #1 testing 2 non-io opens (no delete)\n");
4990         status = cli_ntcreate(cli1, fname, 0, FILE_READ_ATTRIBUTES,
4991                               FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE,
4992                               FILE_OVERWRITE_IF, 0, 0, &fnum1);
4993         if (!NT_STATUS_IS_OK(status)) {
4994                 printf("TEST #1 open 1 of %s failed (%s)\n", fname, nt_errstr(status));
4995                 return False;
4996         }
4997
4998         status = cli_ntcreate(cli2, fname, 0, FILE_READ_ATTRIBUTES,
4999                               FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE,
5000                               FILE_OPEN_IF, 0, 0, &fnum2);
5001         if (!NT_STATUS_IS_OK(status)) {
5002                 printf("TEST #1 open 2 of %s failed (%s)\n", fname, nt_errstr(status));
5003                 return False;
5004         }
5005
5006         status = cli_close(cli1, fnum1);
5007         if (!NT_STATUS_IS_OK(status)) {
5008                 printf("TEST #1 close 1 of %s failed (%s)\n", fname, nt_errstr(status));
5009                 return False;
5010         }
5011
5012         status = cli_close(cli2, fnum2);
5013         if (!NT_STATUS_IS_OK(status)) {
5014                 printf("TEST #1 close 2 of %s failed (%s)\n", fname, nt_errstr(status));
5015                 return False;
5016         }
5017
5018         printf("non-io open test #1 passed.\n");
5019
5020         cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
5021
5022         printf("TEST #2 testing 2 non-io opens (first with delete)\n");
5023
5024         status = cli_ntcreate(cli1, fname, 0,
5025                               DELETE_ACCESS|FILE_READ_ATTRIBUTES,
5026                               FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE,
5027                               FILE_OVERWRITE_IF, 0, 0, &fnum1);
5028         if (!NT_STATUS_IS_OK(status)) {
5029                 printf("TEST #2 open 1 of %s failed (%s)\n", fname, nt_errstr(status));
5030                 return False;
5031         }
5032
5033         status = cli_ntcreate(cli2, fname, 0, FILE_READ_ATTRIBUTES,
5034                               FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE,
5035                               FILE_OPEN_IF, 0, 0, &fnum2);
5036         if (!NT_STATUS_IS_OK(status)) {
5037                 printf("TEST #2 open 2 of %s failed (%s)\n", fname, nt_errstr(status));
5038                 return False;
5039         }
5040
5041         status = cli_close(cli1, fnum1);
5042         if (!NT_STATUS_IS_OK(status)) {
5043                 printf("TEST #2 close 1 of %s failed (%s)\n", fname, nt_errstr(status));
5044                 return False;
5045         }
5046
5047         status = cli_close(cli2, fnum2);
5048         if (!NT_STATUS_IS_OK(status)) {
5049                 printf("TEST #2 close 2 of %s failed (%s)\n", fname, nt_errstr(status));
5050                 return False;
5051         }
5052
5053         printf("non-io open test #2 passed.\n");
5054
5055         cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
5056
5057         printf("TEST #3 testing 2 non-io opens (second with delete)\n");
5058
5059         status = cli_ntcreate(cli1, fname, 0, FILE_READ_ATTRIBUTES,
5060                               FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE,
5061                               FILE_OVERWRITE_IF, 0, 0, &fnum1);
5062         if (!NT_STATUS_IS_OK(status)) {
5063                 printf("TEST #3 open 1 of %s failed (%s)\n", fname, nt_errstr(status));
5064                 return False;
5065         }
5066
5067         status = cli_ntcreate(cli2, fname, 0,
5068                               DELETE_ACCESS|FILE_READ_ATTRIBUTES,
5069                               FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE,
5070                               FILE_OPEN_IF, 0, 0, &fnum2);
5071         if (!NT_STATUS_IS_OK(status)) {
5072                 printf("TEST #3 open 2 of %s failed (%s)\n", fname, nt_errstr(status));
5073                 return False;
5074         }
5075
5076         status = cli_close(cli1, fnum1);
5077         if (!NT_STATUS_IS_OK(status)) {
5078                 printf("TEST #3 close 1 of %s failed (%s)\n", fname, nt_errstr(status));
5079                 return False;
5080         }
5081
5082         status = cli_close(cli2, fnum2);
5083         if (!NT_STATUS_IS_OK(status)) {
5084                 printf("TEST #3 close 2 of %s failed (%s)\n", fname, nt_errstr(status));
5085                 return False;
5086         }
5087
5088         printf("non-io open test #3 passed.\n");
5089
5090         cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
5091
5092         printf("TEST #4 testing 2 non-io opens (both with delete)\n");
5093
5094         status = cli_ntcreate(cli1, fname, 0,
5095                                DELETE_ACCESS|FILE_READ_ATTRIBUTES,
5096                                FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE,
5097                                FILE_OVERWRITE_IF, 0, 0, &fnum1);
5098         if (!NT_STATUS_IS_OK(status)) {
5099                 printf("TEST #4 open 1 of %s failed (%s)\n", fname, nt_errstr(status));
5100                 return False;
5101         }
5102
5103         status = cli_ntcreate(cli2, fname, 0,
5104                               DELETE_ACCESS|FILE_READ_ATTRIBUTES,
5105                               FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE,
5106                               FILE_OPEN_IF, 0, 0, &fnum2);
5107         if (NT_STATUS_IS_OK(status)) {
5108                 printf("TEST #4 open 2 of %s SUCCEEDED - should have failed (%s)\n", fname, nt_errstr(status));
5109                 return False;
5110         }
5111
5112         printf("TEST #4 open 2 of %s gave %s (correct error should be %s)\n", fname, nt_errstr(status), "sharing violation");
5113
5114         status = cli_close(cli1, fnum1);
5115         if (!NT_STATUS_IS_OK(status)) {
5116                 printf("TEST #4 close 1 of %s failed (%s)\n", fname, nt_errstr(status));
5117                 return False;
5118         }
5119
5120         printf("non-io open test #4 passed.\n");
5121
5122         cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
5123
5124         printf("TEST #5 testing 2 non-io opens (both with delete - both with file share delete)\n");
5125
5126         status = cli_ntcreate(cli1, fname, 0,
5127                               DELETE_ACCESS|FILE_READ_ATTRIBUTES,
5128                               FILE_ATTRIBUTE_NORMAL, FILE_SHARE_DELETE,
5129                               FILE_OVERWRITE_IF, 0, 0, &fnum1);
5130         if (!NT_STATUS_IS_OK(status)) {
5131                 printf("TEST #5 open 1 of %s failed (%s)\n", fname, nt_errstr(status));
5132                 return False;
5133         }
5134
5135         status = cli_ntcreate(cli2, fname, 0,
5136                               DELETE_ACCESS|FILE_READ_ATTRIBUTES,
5137                               FILE_ATTRIBUTE_NORMAL, FILE_SHARE_DELETE,
5138                               FILE_OPEN_IF, 0, 0, &fnum2);
5139         if (!NT_STATUS_IS_OK(status)) {
5140                 printf("TEST #5 open 2 of %s failed (%s)\n", fname, nt_errstr(status));
5141                 return False;
5142         }
5143
5144         status = cli_close(cli1, fnum1);
5145         if (!NT_STATUS_IS_OK(status)) {
5146                 printf("TEST #5 close 1 of %s failed (%s)\n", fname, nt_errstr(status));
5147                 return False;
5148         }
5149
5150         status = cli_close(cli2, fnum2);
5151         if (!NT_STATUS_IS_OK(status)) {
5152                 printf("TEST #5 close 2 of %s failed (%s)\n", fname, nt_errstr(status));
5153                 return False;
5154         }
5155
5156         printf("non-io open test #5 passed.\n");
5157
5158         printf("TEST #6 testing 1 non-io open, one io open\n");
5159
5160         cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
5161
5162         status = cli_ntcreate(cli1, fname, 0, FILE_READ_DATA,
5163                               FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE,
5164                               FILE_OVERWRITE_IF, 0, 0, &fnum1);
5165         if (!NT_STATUS_IS_OK(status)) {
5166                 printf("TEST #6 open 1 of %s failed (%s)\n", fname, nt_errstr(status));
5167                 return False;
5168         }
5169
5170         status = cli_ntcreate(cli2, fname, 0, FILE_READ_ATTRIBUTES,
5171                               FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ,
5172                               FILE_OPEN_IF, 0, 0, &fnum2);
5173         if (!NT_STATUS_IS_OK(status)) {
5174                 printf("TEST #6 open 2 of %s failed (%s)\n", fname, nt_errstr(status));
5175                 return False;
5176         }
5177
5178         status = cli_close(cli1, fnum1);
5179         if (!NT_STATUS_IS_OK(status)) {
5180                 printf("TEST #6 close 1 of %s failed (%s)\n", fname, nt_errstr(status));
5181                 return False;
5182         }
5183
5184         status = cli_close(cli2, fnum2);
5185         if (!NT_STATUS_IS_OK(status)) {
5186                 printf("TEST #6 close 2 of %s failed (%s)\n", fname, nt_errstr(status));
5187                 return False;
5188         }
5189
5190         printf("non-io open test #6 passed.\n");
5191
5192         printf("TEST #7 testing 1 non-io open, one io open with delete\n");
5193
5194         cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
5195
5196         status = cli_ntcreate(cli1, fname, 0, FILE_READ_DATA,
5197                               FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE,
5198                               FILE_OVERWRITE_IF, 0, 0, &fnum1);
5199         if (!NT_STATUS_IS_OK(status)) {
5200                 printf("TEST #7 open 1 of %s failed (%s)\n", fname, nt_errstr(status));
5201                 return False;
5202         }
5203
5204         status = cli_ntcreate(cli2, fname, 0,
5205                               DELETE_ACCESS|FILE_READ_ATTRIBUTES,
5206                               FILE_ATTRIBUTE_NORMAL,
5207                               FILE_SHARE_READ|FILE_SHARE_DELETE,
5208                               FILE_OPEN_IF, 0, 0, &fnum2);
5209         if (NT_STATUS_IS_OK(status)) {
5210                 printf("TEST #7 open 2 of %s SUCCEEDED - should have failed (%s)\n", fname, nt_errstr(status));
5211                 return False;
5212         }
5213
5214         printf("TEST #7 open 2 of %s gave %s (correct error should be %s)\n", fname, nt_errstr(status), "sharing violation");
5215
5216         status = cli_close(cli1, fnum1);
5217         if (!NT_STATUS_IS_OK(status)) {
5218                 printf("TEST #7 close 1 of %s failed (%s)\n", fname, nt_errstr(status));
5219                 return False;
5220         }
5221
5222         printf("non-io open test #7 passed.\n");
5223
5224         cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
5225
5226         printf("TEST #8 testing open without WRITE_ATTRIBUTES, updating close write time.\n");
5227         status = cli_ntcreate(cli1, fname, 0, FILE_WRITE_DATA, FILE_ATTRIBUTE_NORMAL,
5228                                 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
5229                                 FILE_OVERWRITE_IF, 0, 0, &fnum1);
5230         if (!NT_STATUS_IS_OK(status)) {
5231                 printf("TEST #8 open of %s failed (%s)\n", fname, nt_errstr(status));
5232                 correct = false;
5233                 goto out;
5234         }
5235
5236         /* Write to ensure we have to update the file time. */
5237         status = cli_writeall(cli1, fnum1, 0, (const uint8_t *)"TEST DATA\n", 0, 10,
5238                               NULL);
5239         if (!NT_STATUS_IS_OK(status)) {
5240                 printf("TEST #8 cli_write failed: %s\n", nt_errstr(status));
5241                 correct = false;
5242                 goto out;
5243         }
5244
5245         status = cli_close(cli1, fnum1);
5246         if (!NT_STATUS_IS_OK(status)) {
5247                 printf("TEST #8 close of %s failed (%s)\n", fname, nt_errstr(status));
5248                 correct = false;
5249         }
5250
5251   out:
5252
5253         if (!torture_close_connection(cli1)) {
5254                 correct = False;
5255         }
5256         if (!torture_close_connection(cli2)) {
5257                 correct = False;
5258         }
5259
5260         return correct;
5261 }
5262
5263 NTSTATUS torture_setup_unix_extensions(struct cli_state *cli)
5264 {
5265         uint16 major, minor;
5266         uint32 caplow, caphigh;
5267         NTSTATUS status;
5268
5269         if (!SERVER_HAS_UNIX_CIFS(cli)) {
5270                 printf("Server doesn't support UNIX CIFS extensions.\n");
5271                 return NT_STATUS_NOT_SUPPORTED;
5272         }
5273
5274         status = cli_unix_extensions_version(cli, &major, &minor, &caplow,
5275                                              &caphigh);
5276         if (!NT_STATUS_IS_OK(status)) {
5277                 printf("Server didn't return UNIX CIFS extensions: %s\n",
5278                        nt_errstr(status));
5279                 return status;
5280         }
5281
5282         status = cli_set_unix_extensions_capabilities(cli, major, minor,
5283                                                       caplow, caphigh);
5284         if (!NT_STATUS_IS_OK(status)) {
5285                 printf("Server doesn't support setting UNIX CIFS extensions: "
5286                        "%s.\n", nt_errstr(status));
5287                 return status;
5288         }
5289
5290         return NT_STATUS_OK;
5291 }
5292
5293 /*
5294   Test POSIX open /mkdir calls.
5295  */
5296 static bool run_simple_posix_open_test(int dummy)
5297 {
5298         static struct cli_state *cli1;
5299         const char *fname = "posix:file";
5300         const char *hname = "posix:hlink";
5301         const char *sname = "posix:symlink";
5302         const char *dname = "posix:dir";
5303         char buf[10];
5304         char namebuf[11];
5305         uint16_t fnum1 = (uint16_t)-1;
5306         SMB_STRUCT_STAT sbuf;
5307         bool correct = false;
5308         NTSTATUS status;
5309         size_t nread;
5310
5311         printf("Starting simple POSIX open test\n");
5312
5313         if (!torture_open_connection(&cli1, 0)) {
5314                 return false;
5315         }
5316
5317         smbXcli_conn_set_sockopt(cli1->conn, sockops);
5318
5319         status = torture_setup_unix_extensions(cli1);
5320         if (!NT_STATUS_IS_OK(status)) {
5321                 return false;
5322         }
5323
5324         cli_setatr(cli1, fname, 0, 0);
5325         cli_posix_unlink(cli1, fname);
5326         cli_setatr(cli1, dname, 0, 0);
5327         cli_posix_rmdir(cli1, dname);
5328         cli_setatr(cli1, hname, 0, 0);
5329         cli_posix_unlink(cli1, hname);
5330         cli_setatr(cli1, sname, 0, 0);
5331         cli_posix_unlink(cli1, sname);
5332
5333         /* Create a directory. */
5334         status = cli_posix_mkdir(cli1, dname, 0777);
5335         if (!NT_STATUS_IS_OK(status)) {
5336                 printf("POSIX mkdir of %s failed (%s)\n", dname, nt_errstr(status));
5337                 goto out;
5338         }
5339
5340         status = cli_posix_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL,
5341                                 0600, &fnum1);
5342         if (!NT_STATUS_IS_OK(status)) {
5343                 printf("POSIX create of %s failed (%s)\n", fname, nt_errstr(status));
5344                 goto out;
5345         }
5346
5347         /* Test ftruncate - set file size. */
5348         status = cli_ftruncate(cli1, fnum1, 1000);
5349         if (!NT_STATUS_IS_OK(status)) {
5350                 printf("ftruncate failed (%s)\n", nt_errstr(status));
5351                 goto out;
5352         }
5353
5354         /* Ensure st_size == 1000 */
5355         status = cli_posix_stat(cli1, fname, &sbuf);
5356         if (!NT_STATUS_IS_OK(status)) {
5357                 printf("stat failed (%s)\n", nt_errstr(status));
5358                 goto out;
5359         }
5360
5361         if (sbuf.st_ex_size != 1000) {
5362                 printf("ftruncate - stat size (%u) != 1000\n", (unsigned int)sbuf.st_ex_size);
5363                 goto out;
5364         }
5365
5366         /* Ensure st_mode == 0600 */
5367         if ((sbuf.st_ex_mode & 07777) != 0600) {
5368                 printf("posix_open - bad permissions 0%o != 0600\n",
5369                                 (unsigned int)(sbuf.st_ex_mode & 07777));
5370                 goto out;
5371         }
5372
5373         /* Test ftruncate - set file size back to zero. */
5374         status = cli_ftruncate(cli1, fnum1, 0);
5375         if (!NT_STATUS_IS_OK(status)) {
5376                 printf("ftruncate failed (%s)\n", nt_errstr(status));
5377                 goto out;
5378         }
5379
5380         status = cli_close(cli1, fnum1);
5381         if (!NT_STATUS_IS_OK(status)) {
5382                 printf("close failed (%s)\n", nt_errstr(status));
5383                 goto out;
5384         }
5385
5386         /* Now open the file again for read only. */
5387         status = cli_posix_open(cli1, fname, O_RDONLY, 0, &fnum1);
5388         if (!NT_STATUS_IS_OK(status)) {
5389                 printf("POSIX open of %s failed (%s)\n", fname, nt_errstr(status));
5390                 goto out;
5391         }
5392
5393         /* Now unlink while open. */
5394         status = cli_posix_unlink(cli1, fname);
5395         if (!NT_STATUS_IS_OK(status)) {
5396                 printf("POSIX unlink of %s failed (%s)\n", fname, nt_errstr(status));
5397                 goto out;
5398         }
5399
5400         status = cli_close(cli1, fnum1);
5401         if (!NT_STATUS_IS_OK(status)) {
5402                 printf("close(2) failed (%s)\n", nt_errstr(status));
5403                 goto out;
5404         }
5405
5406         /* Ensure the file has gone. */
5407         status = cli_posix_open(cli1, fname, O_RDONLY, 0, &fnum1);
5408         if (NT_STATUS_IS_OK(status)) {
5409                 printf("POSIX open of %s succeeded, should have been deleted.\n", fname);
5410                 goto out;
5411         }
5412
5413         /* Create again to test open with O_TRUNC. */
5414         status = cli_posix_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, 0600, &fnum1);
5415         if (!NT_STATUS_IS_OK(status)) {
5416                 printf("POSIX create of %s failed (%s)\n", fname, nt_errstr(status));
5417                 goto out;
5418         }
5419
5420         /* Test ftruncate - set file size. */
5421         status = cli_ftruncate(cli1, fnum1, 1000);
5422         if (!NT_STATUS_IS_OK(status)) {
5423                 printf("ftruncate failed (%s)\n", nt_errstr(status));
5424                 goto out;
5425         }
5426
5427         /* Ensure st_size == 1000 */
5428         status = cli_posix_stat(cli1, fname, &sbuf);
5429         if (!NT_STATUS_IS_OK(status)) {
5430                 printf("stat failed (%s)\n", nt_errstr(status));
5431                 goto out;
5432         }
5433
5434         if (sbuf.st_ex_size != 1000) {
5435                 printf("ftruncate - stat size (%u) != 1000\n", (unsigned int)sbuf.st_ex_size);
5436                 goto out;
5437         }
5438
5439         status = cli_close(cli1, fnum1);
5440         if (!NT_STATUS_IS_OK(status)) {
5441                 printf("close(2) failed (%s)\n", nt_errstr(status));
5442                 goto out;
5443         }
5444
5445         /* Re-open with O_TRUNC. */
5446         status = cli_posix_open(cli1, fname, O_WRONLY|O_TRUNC, 0600, &fnum1);
5447         if (!NT_STATUS_IS_OK(status)) {
5448                 printf("POSIX create of %s failed (%s)\n", fname, nt_errstr(status));
5449                 goto out;
5450         }
5451
5452         /* Ensure st_size == 0 */
5453         status = cli_posix_stat(cli1, fname, &sbuf);
5454         if (!NT_STATUS_IS_OK(status)) {
5455                 printf("stat failed (%s)\n", nt_errstr(status));
5456                 goto out;
5457         }
5458
5459         if (sbuf.st_ex_size != 0) {
5460                 printf("O_TRUNC - stat size (%u) != 0\n", (unsigned int)sbuf.st_ex_size);
5461                 goto out;
5462         }
5463
5464         status = cli_close(cli1, fnum1);
5465         if (!NT_STATUS_IS_OK(status)) {
5466                 printf("close failed (%s)\n", nt_errstr(status));
5467                 goto out;
5468         }
5469
5470         status = cli_posix_unlink(cli1, fname);
5471         if (!NT_STATUS_IS_OK(status)) {
5472                 printf("POSIX unlink of %s failed (%s)\n", fname, nt_errstr(status));
5473                 goto out;
5474         }
5475
5476         status = cli_posix_open(cli1, dname, O_RDONLY, 0, &fnum1);
5477         if (!NT_STATUS_IS_OK(status)) {
5478                 printf("POSIX open directory O_RDONLY of %s failed (%s)\n",
5479                         dname, nt_errstr(status));
5480                 goto out;
5481         }
5482
5483         cli_close(cli1, fnum1);
5484
5485         /* What happens when we try and POSIX open a directory for write ? */
5486         status = cli_posix_open(cli1, dname, O_RDWR, 0, &fnum1);
5487         if (NT_STATUS_IS_OK(status)) {
5488                 printf("POSIX open of directory %s succeeded, should have failed.\n", fname);
5489                 goto out;
5490         } else {
5491                 if (!check_both_error(__LINE__, status, ERRDOS, EISDIR,
5492                                 NT_STATUS_FILE_IS_A_DIRECTORY)) {
5493                         goto out;
5494                 }
5495         }
5496
5497         /* Create the file. */
5498         status = cli_posix_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL,
5499                                 0600, &fnum1);
5500         if (!NT_STATUS_IS_OK(status)) {
5501                 printf("POSIX create of %s failed (%s)\n", fname, nt_errstr(status));
5502                 goto out;
5503         }
5504
5505         /* Write some data into it. */
5506         status = cli_writeall(cli1, fnum1, 0, (const uint8_t *)"TEST DATA\n", 0, 10,
5507                               NULL);
5508         if (!NT_STATUS_IS_OK(status)) {
5509                 printf("cli_write failed: %s\n", nt_errstr(status));
5510                 goto out;
5511         }
5512
5513         cli_close(cli1, fnum1);
5514
5515         /* Now create a hardlink. */
5516         status = cli_posix_hardlink(cli1, fname, hname);
5517         if (!NT_STATUS_IS_OK(status)) {
5518                 printf("POSIX hardlink of %s failed (%s)\n", hname, nt_errstr(status));
5519                 goto out;
5520         }
5521
5522         /* Now create a symlink. */
5523         status = cli_posix_symlink(cli1, fname, sname);
5524         if (!NT_STATUS_IS_OK(status)) {
5525                 printf("POSIX symlink of %s failed (%s)\n", sname, nt_errstr(status));
5526                 goto out;
5527         }
5528
5529         /* Open the hardlink for read. */
5530         status = cli_posix_open(cli1, hname, O_RDONLY, 0, &fnum1);
5531         if (!NT_STATUS_IS_OK(status)) {
5532                 printf("POSIX open of %s failed (%s)\n", hname, nt_errstr(status));
5533                 goto out;
5534         }
5535
5536         status = cli_read(cli1, fnum1, buf, 0, 10, &nread);
5537         if (!NT_STATUS_IS_OK(status)) {
5538                 printf("POSIX read of %s failed (%s)\n", hname,
5539                        nt_errstr(status));
5540                 goto out;
5541         } else if (nread != 10) {
5542                 printf("POSIX read of %s failed. Received %ld, expected %d\n",
5543                        hname, (unsigned long)nread, 10);
5544                 goto out;
5545         }
5546
5547         if (memcmp(buf, "TEST DATA\n", 10)) {
5548                 printf("invalid data read from hardlink\n");
5549                 goto out;
5550         }
5551
5552         /* Do a POSIX lock/unlock. */
5553         status = cli_posix_lock(cli1, fnum1, 0, 100, true, READ_LOCK);
5554         if (!NT_STATUS_IS_OK(status)) {
5555                 printf("POSIX lock failed %s\n", nt_errstr(status));
5556                 goto out;
5557         }
5558
5559         /* Punch a hole in the locked area. */
5560         status = cli_posix_unlock(cli1, fnum1, 10, 80);
5561         if (!NT_STATUS_IS_OK(status)) {
5562                 printf("POSIX unlock failed %s\n", nt_errstr(status));
5563                 goto out;
5564         }
5565
5566         cli_close(cli1, fnum1);
5567
5568         /* Open the symlink for read - this should fail. A POSIX
5569            client should not be doing opens on a symlink. */
5570         status = cli_posix_open(cli1, sname, O_RDONLY, 0, &fnum1);
5571         if (NT_STATUS_IS_OK(status)) {
5572                 printf("POSIX open of %s succeeded (should have failed)\n", sname);
5573                 goto out;
5574         } else {
5575                 if (!check_both_error(__LINE__, status, ERRDOS, ERRbadpath,
5576                                 NT_STATUS_OBJECT_PATH_NOT_FOUND)) {
5577                         printf("POSIX open of %s should have failed "
5578                                 "with NT_STATUS_OBJECT_PATH_NOT_FOUND, "
5579                                 "failed with %s instead.\n",
5580                                 sname, nt_errstr(status));
5581                         goto out;
5582                 }
5583         }
5584
5585         status = cli_posix_readlink(cli1, sname, namebuf, sizeof(namebuf));
5586         if (!NT_STATUS_IS_OK(status)) {
5587                 printf("POSIX readlink on %s failed (%s)\n", sname, nt_errstr(status));
5588                 goto out;
5589         }
5590
5591         if (strcmp(namebuf, fname) != 0) {
5592                 printf("POSIX readlink on %s failed to match name %s (read %s)\n",
5593                         sname, fname, namebuf);
5594                 goto out;
5595         }
5596
5597         status = cli_posix_rmdir(cli1, dname);
5598         if (!NT_STATUS_IS_OK(status)) {
5599                 printf("POSIX rmdir failed (%s)\n", nt_errstr(status));
5600                 goto out;
5601         }
5602
5603         /* Check directory opens with a specific permission. */
5604         status = cli_posix_mkdir(cli1, dname, 0700);
5605         if (!NT_STATUS_IS_OK(status)) {
5606                 printf("POSIX mkdir of %s failed (%s)\n", dname, nt_errstr(status));
5607                 goto out;
5608         }
5609
5610         /* Ensure st_mode == 0700 */
5611         status = cli_posix_stat(cli1, dname, &sbuf);
5612         if (!NT_STATUS_IS_OK(status)) {
5613                 printf("stat failed (%s)\n", nt_errstr(status));
5614                 goto out;
5615         }
5616
5617         if ((sbuf.st_ex_mode & 07777) != 0700) {
5618                 printf("posix_mkdir - bad permissions 0%o != 0700\n",
5619                                 (unsigned int)(sbuf.st_ex_mode & 07777));
5620                 goto out;
5621         }
5622
5623         printf("Simple POSIX open test passed\n");
5624         correct = true;
5625
5626   out:
5627
5628         if (fnum1 != (uint16_t)-1) {
5629                 cli_close(cli1, fnum1);
5630                 fnum1 = (uint16_t)-1;
5631         }
5632
5633         cli_setatr(cli1, sname, 0, 0);
5634         cli_posix_unlink(cli1, sname);
5635         cli_setatr(cli1, hname, 0, 0);
5636         cli_posix_unlink(cli1, hname);
5637         cli_setatr(cli1, fname, 0, 0);
5638         cli_posix_unlink(cli1, fname);
5639         cli_setatr(cli1, dname, 0, 0);
5640         cli_posix_rmdir(cli1, dname);
5641
5642         if (!torture_close_connection(cli1)) {
5643                 correct = false;
5644         }
5645
5646         return correct;
5647 }
5648
5649
5650 static uint32 open_attrs_table[] = {
5651                 FILE_ATTRIBUTE_NORMAL,
5652                 FILE_ATTRIBUTE_ARCHIVE,
5653                 FILE_ATTRIBUTE_READONLY,
5654                 FILE_ATTRIBUTE_HIDDEN,
5655                 FILE_ATTRIBUTE_SYSTEM,
5656
5657                 FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY,
5658                 FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN,
5659                 FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM,
5660                 FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN,
5661                 FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM,
5662                 FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN|FILE_ATTRIBUTE_SYSTEM,
5663
5664                 FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN,
5665                 FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM,
5666                 FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN|FILE_ATTRIBUTE_SYSTEM,
5667                 FILE_ATTRIBUTE_HIDDEN,FILE_ATTRIBUTE_SYSTEM,
5668 };
5669
5670 struct trunc_open_results {
5671         unsigned int num;
5672         uint32 init_attr;
5673         uint32 trunc_attr;
5674         uint32 result_attr;
5675 };
5676
5677 static struct trunc_open_results attr_results[] = {
5678         { 0, FILE_ATTRIBUTE_NORMAL, FILE_ATTRIBUTE_NORMAL, FILE_ATTRIBUTE_ARCHIVE },
5679         { 1, FILE_ATTRIBUTE_NORMAL, FILE_ATTRIBUTE_ARCHIVE, FILE_ATTRIBUTE_ARCHIVE },
5680         { 2, FILE_ATTRIBUTE_NORMAL, FILE_ATTRIBUTE_READONLY, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY },
5681         { 16, FILE_ATTRIBUTE_ARCHIVE, FILE_ATTRIBUTE_NORMAL, FILE_ATTRIBUTE_ARCHIVE },
5682         { 17, FILE_ATTRIBUTE_ARCHIVE, FILE_ATTRIBUTE_ARCHIVE, FILE_ATTRIBUTE_ARCHIVE },
5683         { 18, FILE_ATTRIBUTE_ARCHIVE, FILE_ATTRIBUTE_READONLY, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY },
5684         { 51, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN },
5685         { 54, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN },
5686         { 56, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN },
5687         { 68, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM },
5688         { 71, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM },
5689         { 73, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM },
5690         { 99, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_HIDDEN,FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN },
5691         { 102, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN },
5692         { 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 },
5693         { 116, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM },
5694         { 119,  FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM,  FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM },
5695         { 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 },
5696         { 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 },
5697         { 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 },
5698         { 227, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN },
5699         { 230, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN },
5700         { 232, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN },
5701         { 244, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM },
5702         { 247, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM },
5703         { 249, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM }
5704 };
5705
5706 static bool run_openattrtest(int dummy)
5707 {
5708         static struct cli_state *cli1;
5709         const char *fname = "\\openattr.file";
5710         uint16_t fnum1;
5711         bool correct = True;
5712         uint16 attr;
5713         unsigned int i, j, k, l;
5714         NTSTATUS status;
5715
5716         printf("starting open attr test\n");
5717
5718         if (!torture_open_connection(&cli1, 0)) {
5719                 return False;
5720         }
5721
5722         smbXcli_conn_set_sockopt(cli1->conn, sockops);
5723
5724         for (k = 0, i = 0; i < sizeof(open_attrs_table)/sizeof(uint32); i++) {
5725                 cli_setatr(cli1, fname, 0, 0);
5726                 cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
5727
5728                 status = cli_ntcreate(cli1, fname, 0, FILE_WRITE_DATA,
5729                                        open_attrs_table[i], FILE_SHARE_NONE,
5730                                        FILE_OVERWRITE_IF, 0, 0, &fnum1);
5731                 if (!NT_STATUS_IS_OK(status)) {
5732                         printf("open %d (1) of %s failed (%s)\n", i, fname, nt_errstr(status));
5733                         return False;
5734                 }
5735
5736                 status = cli_close(cli1, fnum1);
5737                 if (!NT_STATUS_IS_OK(status)) {
5738                         printf("close %d (1) of %s failed (%s)\n", i, fname, nt_errstr(status));
5739                         return False;
5740                 }
5741
5742                 for (j = 0; j < sizeof(open_attrs_table)/sizeof(uint32); j++) {
5743                         status = cli_ntcreate(cli1, fname, 0,
5744                                               FILE_READ_DATA|FILE_WRITE_DATA,
5745                                               open_attrs_table[j],
5746                                               FILE_SHARE_NONE, FILE_OVERWRITE,
5747                                               0, 0, &fnum1);
5748                         if (!NT_STATUS_IS_OK(status)) {
5749                                 for (l = 0; l < sizeof(attr_results)/sizeof(struct trunc_open_results); l++) {
5750                                         if (attr_results[l].num == k) {
5751                                                 printf("[%d] trunc open 0x%x -> 0x%x of %s failed - should have succeeded !(0x%x:%s)\n",
5752                                                                 k, open_attrs_table[i],
5753                                                                 open_attrs_table[j],
5754                                                                 fname, NT_STATUS_V(status), nt_errstr(status));
5755                                                 correct = False;
5756                                         }
5757                                 }
5758
5759                                 if (!NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED)) {
5760                                         printf("[%d] trunc open 0x%x -> 0x%x failed with wrong error code %s\n",
5761                                                         k, open_attrs_table[i], open_attrs_table[j],
5762                                                         nt_errstr(status));
5763                                         correct = False;
5764                                 }
5765 #if 0
5766                                 printf("[%d] trunc open 0x%x -> 0x%x failed\n", k, open_attrs_table[i], open_attrs_table[j]);
5767 #endif
5768                                 k++;
5769                                 continue;
5770                         }
5771
5772                         status = cli_close(cli1, fnum1);
5773                         if (!NT_STATUS_IS_OK(status)) {
5774                                 printf("close %d (2) of %s failed (%s)\n", j, fname, nt_errstr(status));
5775                                 return False;
5776                         }
5777
5778                         status = cli_getatr(cli1, fname, &attr, NULL, NULL);
5779                         if (!NT_STATUS_IS_OK(status)) {
5780                                 printf("getatr(2) failed (%s)\n", nt_errstr(status));
5781                                 return False;
5782                         }
5783
5784 #if 0
5785                         printf("[%d] getatr check [0x%x] trunc [0x%x] got attr 0x%x\n",
5786                                         k,  open_attrs_table[i],  open_attrs_table[j], attr );
5787 #endif
5788
5789                         for (l = 0; l < sizeof(attr_results)/sizeof(struct trunc_open_results); l++) {
5790                                 if (attr_results[l].num == k) {
5791                                         if (attr != attr_results[l].result_attr ||
5792                                                         open_attrs_table[i] != attr_results[l].init_attr ||
5793                                                         open_attrs_table[j] != attr_results[l].trunc_attr) {
5794                                                 printf("getatr check failed. [0x%x] trunc [0x%x] got attr 0x%x, should be 0x%x\n",
5795                                                 open_attrs_table[i],
5796                                                 open_attrs_table[j],
5797                                                 (unsigned int)attr,
5798                                                 attr_results[l].result_attr);
5799                                                 correct = False;
5800                                         }
5801                                         break;
5802                                 }
5803                         }
5804                         k++;
5805                 }
5806         }
5807
5808         cli_setatr(cli1, fname, 0, 0);
5809         cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
5810
5811         printf("open attr test %s.\n", correct ? "passed" : "failed");
5812
5813         if (!torture_close_connection(cli1)) {
5814                 correct = False;
5815         }
5816         return correct;
5817 }
5818
5819 static NTSTATUS list_fn(const char *mnt, struct file_info *finfo,
5820                     const char *name, void *state)
5821 {
5822         int *matched = (int *)state;
5823         if (matched != NULL) {
5824                 *matched += 1;
5825         }
5826         return NT_STATUS_OK;
5827 }
5828
5829 /*
5830   test directory listing speed
5831  */
5832 static bool run_dirtest(int dummy)
5833 {
5834         int i;
5835         static struct cli_state *cli;
5836         uint16_t fnum;
5837         struct timeval core_start;
5838         bool correct = True;
5839         int matched;
5840
5841         printf("starting directory test\n");
5842
5843         if (!torture_open_connection(&cli, 0)) {
5844                 return False;
5845         }
5846
5847         smbXcli_conn_set_sockopt(cli->conn, sockops);
5848
5849         srandom(0);
5850         for (i=0;i<torture_numops;i++) {
5851                 fstring fname;
5852                 slprintf(fname, sizeof(fname), "\\%x", (int)random());
5853                 if (!NT_STATUS_IS_OK(cli_openx(cli, fname, O_RDWR|O_CREAT, DENY_NONE, &fnum))) {
5854                         fprintf(stderr,"Failed to open %s\n", fname);
5855                         return False;
5856                 }
5857                 cli_close(cli, fnum);
5858         }
5859
5860         core_start = timeval_current();
5861
5862         matched = 0;
5863         cli_list(cli, "a*.*", 0, list_fn, &matched);
5864         printf("Matched %d\n", matched);
5865
5866         matched = 0;
5867         cli_list(cli, "b*.*", 0, list_fn, &matched);
5868         printf("Matched %d\n", matched);
5869
5870         matched = 0;
5871         cli_list(cli, "xyzabc", 0, list_fn, &matched);
5872         printf("Matched %d\n", matched);
5873
5874         printf("dirtest core %g seconds\n", timeval_elapsed(&core_start));
5875
5876         srandom(0);
5877         for (i=0;i<torture_numops;i++) {
5878                 fstring fname;
5879                 slprintf(fname, sizeof(fname), "\\%x", (int)random());
5880                 cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
5881         }
5882
5883         if (!torture_close_connection(cli)) {
5884                 correct = False;
5885         }
5886
5887         printf("finished dirtest\n");
5888
5889         return correct;
5890 }
5891
5892 static NTSTATUS del_fn(const char *mnt, struct file_info *finfo, const char *mask,
5893                    void *state)
5894 {
5895         struct cli_state *pcli = (struct cli_state *)state;
5896         fstring fname;
5897         slprintf(fname, sizeof(fname), "\\LISTDIR\\%s", finfo->name);
5898
5899         if (strcmp(finfo->name, ".") == 0 || strcmp(finfo->name, "..") == 0)
5900                 return NT_STATUS_OK;
5901
5902         if (finfo->mode & FILE_ATTRIBUTE_DIRECTORY) {
5903                 if (!NT_STATUS_IS_OK(cli_rmdir(pcli, fname)))
5904                         printf("del_fn: failed to rmdir %s\n,", fname );
5905         } else {
5906                 if (!NT_STATUS_IS_OK(cli_unlink(pcli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN)))
5907                         printf("del_fn: failed to unlink %s\n,", fname );
5908         }
5909         return NT_STATUS_OK;
5910 }
5911
5912
5913 /*
5914   sees what IOCTLs are supported
5915  */
5916 bool torture_ioctl_test(int dummy)
5917 {
5918         static struct cli_state *cli;
5919         uint16_t device, function;
5920         uint16_t fnum;
5921         const char *fname = "\\ioctl.dat";
5922         DATA_BLOB blob;
5923         NTSTATUS status;
5924
5925         if (!torture_open_connection(&cli, 0)) {
5926                 return False;
5927         }
5928
5929         printf("starting ioctl test\n");
5930
5931         cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
5932
5933         status = cli_openx(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum);
5934         if (!NT_STATUS_IS_OK(status)) {
5935                 printf("open of %s failed (%s)\n", fname, nt_errstr(status));
5936                 return False;
5937         }
5938
5939         status = cli_raw_ioctl(cli, fnum, 0x2d0000 | (0x0420<<2), &blob);
5940         printf("ioctl device info: %s\n", nt_errstr(status));
5941
5942         status = cli_raw_ioctl(cli, fnum, IOCTL_QUERY_JOB_INFO, &blob);
5943         printf("ioctl job info: %s\n", nt_errstr(status));
5944
5945         for (device=0;device<0x100;device++) {
5946                 printf("ioctl test with device = 0x%x\n", device);
5947                 for (function=0;function<0x100;function++) {
5948                         uint32 code = (device<<16) | function;
5949
5950                         status = cli_raw_ioctl(cli, fnum, code, &blob);
5951
5952                         if (NT_STATUS_IS_OK(status)) {
5953                                 printf("ioctl 0x%x OK : %d bytes\n", (int)code,
5954                                        (int)blob.length);
5955                                 data_blob_free(&blob);
5956                         }
5957                 }
5958         }
5959
5960         if (!torture_close_connection(cli)) {
5961                 return False;
5962         }
5963
5964         return True;
5965 }
5966
5967
5968 /*
5969   tries varients of chkpath
5970  */
5971 bool torture_chkpath_test(int dummy)
5972 {
5973         static struct cli_state *cli;
5974         uint16_t fnum;
5975         bool ret;
5976         NTSTATUS status;
5977
5978         if (!torture_open_connection(&cli, 0)) {
5979                 return False;
5980         }
5981
5982         printf("starting chkpath test\n");
5983
5984         /* cleanup from an old run */
5985         cli_rmdir(cli, "\\chkpath.dir\\dir2");
5986         cli_unlink(cli, "\\chkpath.dir\\*", FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
5987         cli_rmdir(cli, "\\chkpath.dir");
5988
5989         status = cli_mkdir(cli, "\\chkpath.dir");
5990         if (!NT_STATUS_IS_OK(status)) {
5991                 printf("mkdir1 failed : %s\n", nt_errstr(status));
5992                 return False;
5993         }
5994
5995         status = cli_mkdir(cli, "\\chkpath.dir\\dir2");
5996         if (!NT_STATUS_IS_OK(status)) {
5997                 printf("mkdir2 failed : %s\n", nt_errstr(status));
5998                 return False;
5999         }
6000
6001         status = cli_openx(cli, "\\chkpath.dir\\foo.txt", O_RDWR|O_CREAT|O_EXCL,
6002                           DENY_NONE, &fnum);
6003         if (!NT_STATUS_IS_OK(status)) {
6004                 printf("open1 failed (%s)\n", nt_errstr(status));
6005                 return False;
6006         }
6007         cli_close(cli, fnum);
6008
6009         status = cli_chkpath(cli, "\\chkpath.dir");
6010         if (!NT_STATUS_IS_OK(status)) {
6011                 printf("chkpath1 failed: %s\n", nt_errstr(status));
6012                 ret = False;
6013         }
6014
6015         status = cli_chkpath(cli, "\\chkpath.dir\\dir2");
6016         if (!NT_STATUS_IS_OK(status)) {
6017                 printf("chkpath2 failed: %s\n", nt_errstr(status));
6018                 ret = False;
6019         }
6020
6021         status = cli_chkpath(cli, "\\chkpath.dir\\foo.txt");
6022         if (!NT_STATUS_IS_OK(status)) {
6023                 ret = check_error(__LINE__, status, ERRDOS, ERRbadpath,
6024                                   NT_STATUS_NOT_A_DIRECTORY);
6025         } else {
6026                 printf("* chkpath on a file should fail\n");
6027                 ret = False;
6028         }
6029
6030         status = cli_chkpath(cli, "\\chkpath.dir\\bar.txt");
6031         if (!NT_STATUS_IS_OK(status)) {
6032                 ret = check_error(__LINE__, status, ERRDOS, ERRbadfile,
6033                                   NT_STATUS_OBJECT_NAME_NOT_FOUND);
6034         } else {
6035                 printf("* chkpath on a non existent file should fail\n");
6036                 ret = False;
6037         }
6038
6039         status = cli_chkpath(cli, "\\chkpath.dir\\dirxx\\bar.txt");
6040         if (!NT_STATUS_IS_OK(status)) {
6041                 ret = check_error(__LINE__, status, ERRDOS, ERRbadpath,
6042                                   NT_STATUS_OBJECT_PATH_NOT_FOUND);
6043         } else {
6044                 printf("* chkpath on a non existent component should fail\n");
6045                 ret = False;
6046         }
6047
6048         cli_rmdir(cli, "\\chkpath.dir\\dir2");
6049         cli_unlink(cli, "\\chkpath.dir\\*", FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
6050         cli_rmdir(cli, "\\chkpath.dir");
6051
6052         if (!torture_close_connection(cli)) {
6053                 return False;
6054         }
6055
6056         return ret;
6057 }
6058
6059 static bool run_eatest(int dummy)
6060 {
6061         static struct cli_state *cli;
6062         const char *fname = "\\eatest.txt";
6063         bool correct = True;
6064         uint16_t fnum;
6065         int i;
6066         size_t num_eas;
6067         struct ea_struct *ea_list = NULL;
6068         TALLOC_CTX *mem_ctx = talloc_init("eatest");
6069         NTSTATUS status;
6070
6071         printf("starting eatest\n");
6072
6073         if (!torture_open_connection(&cli, 0)) {
6074                 talloc_destroy(mem_ctx);
6075                 return False;
6076         }
6077
6078         cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
6079
6080         status = cli_ntcreate(cli, fname, 0,
6081                               FIRST_DESIRED_ACCESS, FILE_ATTRIBUTE_ARCHIVE,
6082                               FILE_SHARE_NONE, FILE_OVERWRITE_IF,
6083                               0x4044, 0, &fnum);
6084         if (!NT_STATUS_IS_OK(status)) {
6085                 printf("open failed - %s\n", nt_errstr(status));
6086                 talloc_destroy(mem_ctx);
6087                 return False;
6088         }
6089
6090         for (i = 0; i < 10; i++) {
6091                 fstring ea_name, ea_val;
6092
6093                 slprintf(ea_name, sizeof(ea_name), "EA_%d", i);
6094                 memset(ea_val, (char)i+1, i+1);
6095                 status = cli_set_ea_fnum(cli, fnum, ea_name, ea_val, i+1);
6096                 if (!NT_STATUS_IS_OK(status)) {
6097                         printf("ea_set of name %s failed - %s\n", ea_name,
6098                                nt_errstr(status));
6099                         talloc_destroy(mem_ctx);
6100                         return False;
6101                 }
6102         }
6103
6104         cli_close(cli, fnum);
6105         for (i = 0; i < 10; i++) {
6106                 fstring ea_name, ea_val;
6107
6108                 slprintf(ea_name, sizeof(ea_name), "EA_%d", i+10);
6109                 memset(ea_val, (char)i+1, i+1);
6110                 status = cli_set_ea_path(cli, fname, ea_name, ea_val, i+1);
6111                 if (!NT_STATUS_IS_OK(status)) {
6112                         printf("ea_set of name %s failed - %s\n", ea_name,
6113                                nt_errstr(status));
6114                         talloc_destroy(mem_ctx);
6115                         return False;
6116                 }
6117         }
6118
6119         status = cli_get_ea_list_path(cli, fname, mem_ctx, &num_eas, &ea_list);
6120         if (!NT_STATUS_IS_OK(status)) {
6121                 printf("ea_get list failed - %s\n", nt_errstr(status));
6122                 correct = False;
6123         }
6124
6125         printf("num_eas = %d\n", (int)num_eas);
6126
6127         if (num_eas != 20) {
6128                 printf("Should be 20 EA's stored... failing.\n");
6129                 correct = False;
6130         }
6131
6132         for (i = 0; i < num_eas; i++) {
6133                 printf("%d: ea_name = %s. Val = ", i, ea_list[i].name);
6134                 dump_data(0, ea_list[i].value.data,
6135                           ea_list[i].value.length);
6136         }
6137
6138         /* Setting EA's to zero length deletes them. Test this */
6139         printf("Now deleting all EA's - case indepenent....\n");
6140
6141 #if 1
6142         cli_set_ea_path(cli, fname, "", "", 0);
6143 #else
6144         for (i = 0; i < 20; i++) {
6145                 fstring ea_name;
6146                 slprintf(ea_name, sizeof(ea_name), "ea_%d", i);
6147                 status = cli_set_ea_path(cli, fname, ea_name, "", 0);
6148                 if (!NT_STATUS_IS_OK(status)) {
6149                         printf("ea_set of name %s failed - %s\n", ea_name,
6150                                nt_errstr(status));
6151                         talloc_destroy(mem_ctx);
6152                         return False;
6153                 }
6154         }
6155 #endif
6156
6157         status = cli_get_ea_list_path(cli, fname, mem_ctx, &num_eas, &ea_list);
6158         if (!NT_STATUS_IS_OK(status)) {
6159                 printf("ea_get list failed - %s\n", nt_errstr(status));
6160                 correct = False;
6161         }
6162
6163         printf("num_eas = %d\n", (int)num_eas);
6164         for (i = 0; i < num_eas; i++) {
6165                 printf("%d: ea_name = %s. Val = ", i, ea_list[i].name);
6166                 dump_data(0, ea_list[i].value.data,
6167                           ea_list[i].value.length);
6168         }
6169
6170         if (num_eas != 0) {
6171                 printf("deleting EA's failed.\n");
6172                 correct = False;
6173         }
6174
6175         /* Try and delete a non existent EA. */
6176         status = cli_set_ea_path(cli, fname, "foo", "", 0);
6177         if (!NT_STATUS_IS_OK(status)) {
6178                 printf("deleting non-existent EA 'foo' should succeed. %s\n",
6179                        nt_errstr(status));
6180                 correct = False;
6181         }
6182
6183         talloc_destroy(mem_ctx);
6184         if (!torture_close_connection(cli)) {
6185                 correct = False;
6186         }
6187
6188         return correct;
6189 }
6190
6191 static bool run_dirtest1(int dummy)
6192 {
6193         int i;
6194         static struct cli_state *cli;
6195         uint16_t fnum;
6196         int num_seen;
6197         bool correct = True;
6198
6199         printf("starting directory test\n");
6200
6201         if (!torture_open_connection(&cli, 0)) {
6202                 return False;
6203         }
6204
6205         smbXcli_conn_set_sockopt(cli->conn, sockops);
6206
6207         cli_list(cli, "\\LISTDIR\\*", 0, del_fn, cli);
6208         cli_list(cli, "\\LISTDIR\\*", FILE_ATTRIBUTE_DIRECTORY, del_fn, cli);
6209         cli_rmdir(cli, "\\LISTDIR");
6210         cli_mkdir(cli, "\\LISTDIR");
6211
6212         /* Create 1000 files and 1000 directories. */
6213         for (i=0;i<1000;i++) {
6214                 fstring fname;
6215                 slprintf(fname, sizeof(fname), "\\LISTDIR\\f%d", i);
6216                 if (!NT_STATUS_IS_OK(cli_ntcreate(cli, fname, 0, GENERIC_ALL_ACCESS, FILE_ATTRIBUTE_ARCHIVE,
6217                                    FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OVERWRITE_IF, 0, 0, &fnum))) {
6218                         fprintf(stderr,"Failed to open %s\n", fname);
6219                         return False;
6220                 }
6221                 cli_close(cli, fnum);
6222         }
6223         for (i=0;i<1000;i++) {
6224                 fstring fname;
6225                 slprintf(fname, sizeof(fname), "\\LISTDIR\\d%d", i);
6226                 if (!NT_STATUS_IS_OK(cli_mkdir(cli, fname))) {
6227                         fprintf(stderr,"Failed to open %s\n", fname);
6228                         return False;
6229                 }
6230         }
6231
6232         /* Now ensure that doing an old list sees both files and directories. */
6233         num_seen = 0;
6234         cli_list_old(cli, "\\LISTDIR\\*", FILE_ATTRIBUTE_DIRECTORY, list_fn, &num_seen);
6235         printf("num_seen = %d\n", num_seen );
6236         /* We should see 100 files + 1000 directories + . and .. */
6237         if (num_seen != 2002)
6238                 correct = False;
6239
6240         /* Ensure if we have the "must have" bits we only see the
6241          * relevent entries.
6242          */
6243         num_seen = 0;
6244         cli_list_old(cli, "\\LISTDIR\\*", (FILE_ATTRIBUTE_DIRECTORY<<8)|FILE_ATTRIBUTE_DIRECTORY, list_fn, &num_seen);
6245         printf("num_seen = %d\n", num_seen );
6246         if (num_seen != 1002)
6247                 correct = False;
6248
6249         num_seen = 0;
6250         cli_list_old(cli, "\\LISTDIR\\*", (FILE_ATTRIBUTE_ARCHIVE<<8)|FILE_ATTRIBUTE_DIRECTORY, list_fn, &num_seen);
6251         printf("num_seen = %d\n", num_seen );
6252         if (num_seen != 1000)
6253                 correct = False;
6254
6255         /* Delete everything. */
6256         cli_list(cli, "\\LISTDIR\\*", 0, del_fn, cli);
6257         cli_list(cli, "\\LISTDIR\\*", FILE_ATTRIBUTE_DIRECTORY, del_fn, cli);
6258         cli_rmdir(cli, "\\LISTDIR");
6259
6260 #if 0
6261         printf("Matched %d\n", cli_list(cli, "a*.*", 0, list_fn, NULL));
6262         printf("Matched %d\n", cli_list(cli, "b*.*", 0, list_fn, NULL));
6263         printf("Matched %d\n", cli_list(cli, "xyzabc", 0, list_fn, NULL));
6264 #endif
6265
6266         if (!torture_close_connection(cli)) {
6267                 correct = False;
6268         }
6269
6270         printf("finished dirtest1\n");
6271
6272         return correct;
6273 }
6274
6275 static bool run_error_map_extract(int dummy) {
6276
6277         static struct cli_state *c_dos;
6278         static struct cli_state *c_nt;
6279         NTSTATUS status;
6280
6281         uint32 error;
6282
6283         uint32 errnum;
6284         uint8 errclass;
6285
6286         NTSTATUS nt_status;
6287
6288         fstring user;
6289
6290         /* NT-Error connection */
6291
6292         disable_spnego = true;
6293         if (!(c_nt = open_nbt_connection())) {
6294                 disable_spnego = false;
6295                 return False;
6296         }
6297         disable_spnego = false;
6298
6299         status = smbXcli_negprot(c_nt->conn, c_nt->timeout, PROTOCOL_CORE,
6300                                  PROTOCOL_NT1);
6301
6302         if (!NT_STATUS_IS_OK(status)) {
6303                 printf("%s rejected the NT-error negprot (%s)\n", host,
6304                        nt_errstr(status));
6305                 cli_shutdown(c_nt);
6306                 return False;
6307         }
6308
6309         status = cli_session_setup(c_nt, "", "", 0, "", 0, workgroup);
6310         if (!NT_STATUS_IS_OK(status)) {
6311                 printf("%s rejected the NT-error initial session setup (%s)\n",host, nt_errstr(status));
6312                 return False;
6313         }
6314
6315         /* DOS-Error connection */
6316
6317         disable_spnego = true;
6318         force_dos_errors = true;
6319         if (!(c_dos = open_nbt_connection())) {
6320                 disable_spnego = false;
6321                 force_dos_errors = false;
6322                 return False;
6323         }
6324         disable_spnego = false;
6325         force_dos_errors = false;
6326
6327         status = smbXcli_negprot(c_dos->conn, c_dos->timeout, PROTOCOL_CORE,
6328                                  PROTOCOL_NT1);
6329         if (!NT_STATUS_IS_OK(status)) {
6330                 printf("%s rejected the DOS-error negprot (%s)\n", host,
6331                        nt_errstr(status));
6332                 cli_shutdown(c_dos);
6333                 return False;
6334         }
6335
6336         status = cli_session_setup(c_dos, "", "", 0, "", 0, workgroup);
6337         if (!NT_STATUS_IS_OK(status)) {
6338                 printf("%s rejected the DOS-error initial session setup (%s)\n",
6339                         host, nt_errstr(status));
6340                 return False;
6341         }
6342
6343         c_nt->map_dos_errors = false;
6344         c_dos->map_dos_errors = false;
6345
6346         for (error=(0xc0000000 | 0x1); error < (0xc0000000| 0xFFF); error++) {
6347                 fstr_sprintf(user, "%X", error);
6348
6349                 status = cli_session_setup(c_nt, user,
6350                                            password, strlen(password),
6351                                            password, strlen(password),
6352                                            workgroup);
6353                 if (NT_STATUS_IS_OK(status)) {
6354                         printf("/** Session setup succeeded.  This shouldn't happen...*/\n");
6355                 }
6356
6357                 /* Case #1: 32-bit NT errors */
6358                 if (!NT_STATUS_IS_DOS(status)) {
6359                         nt_status = status;
6360                 } else {
6361                         printf("/** Dos error on NT connection! (%s) */\n",
6362                                nt_errstr(status));
6363                         nt_status = NT_STATUS(0xc0000000);
6364                 }
6365
6366                 status = cli_session_setup(c_dos, user,
6367                                            password, strlen(password),
6368                                            password, strlen(password),
6369                                            workgroup);
6370                 if (NT_STATUS_IS_OK(status)) {
6371                         printf("/** Session setup succeeded.  This shouldn't happen...*/\n");
6372                 }
6373
6374                 /* Case #1: 32-bit NT errors */
6375                 if (NT_STATUS_IS_DOS(status)) {
6376                         printf("/** NT error on DOS connection! (%s) */\n",
6377                                nt_errstr(status));
6378                         errnum = errclass = 0;
6379                 } else {
6380                         errclass = NT_STATUS_DOS_CLASS(status);
6381                         errnum = NT_STATUS_DOS_CODE(status);
6382                 }
6383
6384                 if (NT_STATUS_V(nt_status) != error) {
6385                         printf("/*\t{ This NT error code was 'sqashed'\n\t from %s to %s \n\t during the session setup }\n*/\n",
6386                                get_nt_error_c_code(talloc_tos(), NT_STATUS(error)),
6387                                get_nt_error_c_code(talloc_tos(), nt_status));
6388                 }
6389
6390                 printf("\t{%s,\t%s,\t%s},\n",
6391                        smb_dos_err_class(errclass),
6392                        smb_dos_err_name(errclass, errnum),
6393                        get_nt_error_c_code(talloc_tos(), NT_STATUS(error)));
6394         }
6395         return True;
6396 }
6397
6398 static bool run_sesssetup_bench(int dummy)
6399 {
6400         static struct cli_state *c;
6401         const char *fname = "\\file.dat";
6402         uint16_t fnum;
6403         NTSTATUS status;
6404         int i;
6405
6406         if (!torture_open_connection(&c, 0)) {
6407                 return false;
6408         }
6409
6410         status = cli_ntcreate(c, fname, 0, GENERIC_ALL_ACCESS|DELETE_ACCESS,
6411                               FILE_ATTRIBUTE_NORMAL, 0, FILE_OVERWRITE_IF,
6412                               FILE_DELETE_ON_CLOSE, 0, &fnum);
6413         if (!NT_STATUS_IS_OK(status)) {
6414                 d_printf("open %s failed: %s\n", fname, nt_errstr(status));
6415                 return false;
6416         }
6417
6418         for (i=0; i<torture_numops; i++) {
6419                 status = cli_session_setup(
6420                         c, username,
6421                         password, strlen(password),
6422                         password, strlen(password),
6423                         workgroup);
6424                 if (!NT_STATUS_IS_OK(status)) {
6425                         d_printf("(%s) cli_session_setup failed: %s\n",
6426                                  __location__, nt_errstr(status));
6427                         return false;
6428                 }
6429
6430                 d_printf("\r%d   ", (int)cli_state_get_uid(c));
6431
6432                 status = cli_ulogoff(c);
6433                 if (!NT_STATUS_IS_OK(status)) {
6434                         d_printf("(%s) cli_ulogoff failed: %s\n",
6435                                  __location__, nt_errstr(status));
6436                         return false;
6437                 }
6438         }
6439
6440         return true;
6441 }
6442
6443 static bool subst_test(const char *str, const char *user, const char *domain,
6444                        uid_t uid, gid_t gid, const char *expected)
6445 {
6446         char *subst;
6447         bool result = true;
6448
6449         subst = talloc_sub_specified(talloc_tos(), str, user, domain, uid, gid);
6450
6451         if (strcmp(subst, expected) != 0) {
6452                 printf("sub_specified(%s, %s, %s, %d, %d) returned [%s], expected "
6453                        "[%s]\n", str, user, domain, (int)uid, (int)gid, subst,
6454                        expected);
6455                 result = false;
6456         }
6457
6458         TALLOC_FREE(subst);
6459         return result;
6460 }
6461
6462 static void chain1_open_completion(struct tevent_req *req)
6463 {
6464         uint16_t fnum;
6465         NTSTATUS status;
6466         status = cli_openx_recv(req, &fnum);
6467         TALLOC_FREE(req);
6468
6469         d_printf("cli_openx_recv returned %s: %d\n",
6470                  nt_errstr(status),
6471                  NT_STATUS_IS_OK(status) ? fnum : -1);
6472 }
6473
6474 static void chain1_write_completion(struct tevent_req *req)
6475 {
6476         size_t written;
6477         NTSTATUS status;
6478         status = cli_write_andx_recv(req, &written);
6479         TALLOC_FREE(req);
6480
6481         d_printf("cli_write_andx_recv returned %s: %d\n",
6482                  nt_errstr(status),
6483                  NT_STATUS_IS_OK(status) ? (int)written : -1);
6484 }
6485
6486 static void chain1_close_completion(struct tevent_req *req)
6487 {
6488         NTSTATUS status;
6489         bool *done = (bool *)tevent_req_callback_data_void(req);
6490
6491         status = cli_close_recv(req);
6492         *done = true;
6493
6494         TALLOC_FREE(req);
6495
6496         d_printf("cli_close returned %s\n", nt_errstr(status));
6497 }
6498
6499 static bool run_chain1(int dummy)
6500 {
6501         struct cli_state *cli1;
6502         struct event_context *evt = event_context_init(NULL);
6503         struct tevent_req *reqs[3], *smbreqs[3];
6504         bool done = false;
6505         const char *str = "foobar";
6506         NTSTATUS status;
6507
6508         printf("starting chain1 test\n");
6509         if (!torture_open_connection(&cli1, 0)) {
6510                 return False;
6511         }
6512
6513         smbXcli_conn_set_sockopt(cli1->conn, sockops);
6514
6515         reqs[0] = cli_openx_create(talloc_tos(), evt, cli1, "\\test",
6516                                   O_CREAT|O_RDWR, 0, &smbreqs[0]);
6517         if (reqs[0] == NULL) return false;
6518         tevent_req_set_callback(reqs[0], chain1_open_completion, NULL);
6519
6520
6521         reqs[1] = cli_write_andx_create(talloc_tos(), evt, cli1, 0, 0,
6522                                         (const uint8_t *)str, 0, strlen(str)+1,
6523                                         smbreqs, 1, &smbreqs[1]);
6524         if (reqs[1] == NULL) return false;
6525         tevent_req_set_callback(reqs[1], chain1_write_completion, NULL);
6526
6527         reqs[2] = cli_close_create(talloc_tos(), evt, cli1, 0, &smbreqs[2]);
6528         if (reqs[2] == NULL) return false;
6529         tevent_req_set_callback(reqs[2], chain1_close_completion, &done);
6530
6531         status = smb1cli_req_chain_submit(smbreqs, ARRAY_SIZE(smbreqs));
6532         if (!NT_STATUS_IS_OK(status)) {
6533                 return false;
6534         }
6535
6536         while (!done) {
6537                 tevent_loop_once(evt);
6538         }
6539
6540         torture_close_connection(cli1);
6541         return True;
6542 }
6543
6544 static void chain2_sesssetup_completion(struct tevent_req *req)
6545 {
6546         NTSTATUS status;
6547         status = cli_session_setup_guest_recv(req);
6548         d_printf("sesssetup returned %s\n", nt_errstr(status));
6549 }
6550
6551 static void chain2_tcon_completion(struct tevent_req *req)
6552 {
6553         bool *done = (bool *)tevent_req_callback_data_void(req);
6554         NTSTATUS status;
6555         status = cli_tcon_andx_recv(req);
6556         d_printf("tcon_and_x returned %s\n", nt_errstr(status));
6557         *done = true;
6558 }
6559
6560 static bool run_chain2(int dummy)
6561 {
6562         struct cli_state *cli1;
6563         struct event_context *evt = event_context_init(NULL);
6564         struct tevent_req *reqs[2], *smbreqs[2];
6565         bool done = false;
6566         NTSTATUS status;
6567
6568         printf("starting chain2 test\n");
6569         status = cli_start_connection(&cli1, lp_netbios_name(), host, NULL,
6570                                       port_to_use, SMB_SIGNING_DEFAULT, 0);
6571         if (!NT_STATUS_IS_OK(status)) {
6572                 return False;
6573         }
6574
6575         smbXcli_conn_set_sockopt(cli1->conn, sockops);
6576
6577         reqs[0] = cli_session_setup_guest_create(talloc_tos(), evt, cli1,
6578                                                  &smbreqs[0]);
6579         if (reqs[0] == NULL) return false;
6580         tevent_req_set_callback(reqs[0], chain2_sesssetup_completion, NULL);
6581
6582         reqs[1] = cli_tcon_andx_create(talloc_tos(), evt, cli1, "IPC$",
6583                                        "?????", NULL, 0, &smbreqs[1]);
6584         if (reqs[1] == NULL) return false;
6585         tevent_req_set_callback(reqs[1], chain2_tcon_completion, &done);
6586
6587         status = smb1cli_req_chain_submit(smbreqs, ARRAY_SIZE(smbreqs));
6588         if (!NT_STATUS_IS_OK(status)) {
6589                 return false;
6590         }
6591
6592         while (!done) {
6593                 tevent_loop_once(evt);
6594         }
6595
6596         torture_close_connection(cli1);
6597         return True;
6598 }
6599
6600
6601 struct torture_createdel_state {
6602         struct tevent_context *ev;
6603         struct cli_state *cli;
6604 };
6605
6606 static void torture_createdel_created(struct tevent_req *subreq);
6607 static void torture_createdel_closed(struct tevent_req *subreq);
6608
6609 static struct tevent_req *torture_createdel_send(TALLOC_CTX *mem_ctx,
6610                                                  struct tevent_context *ev,
6611                                                  struct cli_state *cli,
6612                                                  const char *name)
6613 {
6614         struct tevent_req *req, *subreq;
6615         struct torture_createdel_state *state;
6616
6617         req = tevent_req_create(mem_ctx, &state,
6618                                 struct torture_createdel_state);
6619         if (req == NULL) {
6620                 return NULL;
6621         }
6622         state->ev = ev;
6623         state->cli = cli;
6624
6625         subreq = cli_ntcreate_send(
6626                 state, ev, cli, name, 0,
6627                 FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
6628                 FILE_ATTRIBUTE_NORMAL,
6629                 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
6630                 FILE_OPEN_IF, FILE_DELETE_ON_CLOSE, 0);
6631
6632         if (tevent_req_nomem(subreq, req)) {
6633                 return tevent_req_post(req, ev);
6634         }
6635         tevent_req_set_callback(subreq, torture_createdel_created, req);
6636         return req;
6637 }
6638
6639 static void torture_createdel_created(struct tevent_req *subreq)
6640 {
6641         struct tevent_req *req = tevent_req_callback_data(
6642                 subreq, struct tevent_req);
6643         struct torture_createdel_state *state = tevent_req_data(
6644                 req, struct torture_createdel_state);
6645         NTSTATUS status;
6646         uint16_t fnum;
6647
6648         status = cli_ntcreate_recv(subreq, &fnum);
6649         TALLOC_FREE(subreq);
6650         if (!NT_STATUS_IS_OK(status)) {
6651                 DEBUG(10, ("cli_ntcreate_recv returned %s\n",
6652                            nt_errstr(status)));
6653                 tevent_req_nterror(req, status);
6654                 return;
6655         }
6656
6657         subreq = cli_close_send(state, state->ev, state->cli, fnum);
6658         if (tevent_req_nomem(subreq, req)) {
6659                 return;
6660         }
6661         tevent_req_set_callback(subreq, torture_createdel_closed, req);
6662 }
6663
6664 static void torture_createdel_closed(struct tevent_req *subreq)
6665 {
6666         struct tevent_req *req = tevent_req_callback_data(
6667                 subreq, struct tevent_req);
6668         NTSTATUS status;
6669
6670         status = cli_close_recv(subreq);
6671         if (!NT_STATUS_IS_OK(status)) {
6672                 DEBUG(10, ("cli_close_recv returned %s\n", nt_errstr(status)));
6673                 tevent_req_nterror(req, status);
6674                 return;
6675         }
6676         tevent_req_done(req);
6677 }
6678
6679 static NTSTATUS torture_createdel_recv(struct tevent_req *req)
6680 {
6681         return tevent_req_simple_recv_ntstatus(req);
6682 }
6683
6684 struct torture_createdels_state {
6685         struct tevent_context *ev;
6686         struct cli_state *cli;
6687         const char *base_name;
6688         int sent;
6689         int received;
6690         int num_files;
6691         struct tevent_req **reqs;
6692 };
6693
6694 static void torture_createdels_done(struct tevent_req *subreq);
6695
6696 static struct tevent_req *torture_createdels_send(TALLOC_CTX *mem_ctx,
6697                                                   struct tevent_context *ev,
6698                                                   struct cli_state *cli,
6699                                                   const char *base_name,
6700                                                   int num_parallel,
6701                                                   int num_files)
6702 {
6703         struct tevent_req *req;
6704         struct torture_createdels_state *state;
6705         int i;
6706
6707         req = tevent_req_create(mem_ctx, &state,
6708                                 struct torture_createdels_state);
6709         if (req == NULL) {
6710                 return NULL;
6711         }
6712         state->ev = ev;
6713         state->cli = cli;
6714         state->base_name = talloc_strdup(state, base_name);
6715         if (tevent_req_nomem(state->base_name, req)) {
6716                 return tevent_req_post(req, ev);
6717         }
6718         state->num_files = MAX(num_parallel, num_files);
6719         state->sent = 0;
6720         state->received = 0;
6721
6722         state->reqs = talloc_array(state, struct tevent_req *, num_parallel);
6723         if (tevent_req_nomem(state->reqs, req)) {
6724                 return tevent_req_post(req, ev);
6725         }
6726
6727         for (i=0; i<num_parallel; i++) {
6728                 char *name;
6729
6730                 name = talloc_asprintf(state, "%s%8.8d", state->base_name,
6731                                        state->sent);
6732                 if (tevent_req_nomem(name, req)) {
6733                         return tevent_req_post(req, ev);
6734                 }
6735                 state->reqs[i] = torture_createdel_send(
6736                         state->reqs, state->ev, state->cli, name);
6737                 if (tevent_req_nomem(state->reqs[i], req)) {
6738                         return tevent_req_post(req, ev);
6739                 }
6740                 name = talloc_move(state->reqs[i], &name);
6741                 tevent_req_set_callback(state->reqs[i],
6742                                         torture_createdels_done, req);
6743                 state->sent += 1;
6744         }
6745         return req;
6746 }
6747
6748 static void torture_createdels_done(struct tevent_req *subreq)
6749 {
6750         struct tevent_req *req = tevent_req_callback_data(
6751                 subreq, struct tevent_req);
6752         struct torture_createdels_state *state = tevent_req_data(
6753                 req, struct torture_createdels_state);
6754         size_t num_parallel = talloc_array_length(state->reqs);
6755         NTSTATUS status;
6756         char *name;
6757         int i;
6758
6759         status = torture_createdel_recv(subreq);
6760         if (!NT_STATUS_IS_OK(status)){
6761                 DEBUG(10, ("torture_createdel_recv returned %s\n",
6762                            nt_errstr(status)));
6763                 TALLOC_FREE(subreq);
6764                 tevent_req_nterror(req, status);
6765                 return;
6766         }
6767
6768         for (i=0; i<num_parallel; i++) {
6769                 if (subreq == state->reqs[i]) {
6770                         break;
6771                 }
6772         }
6773         if (i == num_parallel) {
6774                 DEBUG(10, ("received something we did not send\n"));
6775                 tevent_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
6776                 return;
6777         }
6778         TALLOC_FREE(state->reqs[i]);
6779
6780         if (state->sent >= state->num_files) {
6781                 tevent_req_done(req);
6782                 return;
6783         }
6784
6785         name = talloc_asprintf(state, "%s%8.8d", state->base_name,
6786                                state->sent);
6787         if (tevent_req_nomem(name, req)) {
6788                 return;
6789         }
6790         state->reqs[i] = torture_createdel_send(state->reqs, state->ev,
6791                                                 state->cli, name);
6792         if (tevent_req_nomem(state->reqs[i], req)) {
6793                 return;
6794         }
6795         name = talloc_move(state->reqs[i], &name);
6796         tevent_req_set_callback(state->reqs[i], torture_createdels_done, req);
6797         state->sent += 1;
6798 }
6799
6800 static NTSTATUS torture_createdels_recv(struct tevent_req *req)
6801 {
6802         return tevent_req_simple_recv_ntstatus(req);
6803 }
6804
6805 struct swallow_notify_state {
6806         struct tevent_context *ev;
6807         struct cli_state *cli;
6808         uint16_t fnum;
6809         uint32_t completion_filter;
6810         bool recursive;
6811         bool (*fn)(uint32_t action, const char *name, void *priv);
6812         void *priv;
6813 };
6814
6815 static void swallow_notify_done(struct tevent_req *subreq);
6816
6817 static struct tevent_req *swallow_notify_send(TALLOC_CTX *mem_ctx,
6818                                               struct tevent_context *ev,
6819                                               struct cli_state *cli,
6820                                               uint16_t fnum,
6821                                               uint32_t completion_filter,
6822                                               bool recursive,
6823                                               bool (*fn)(uint32_t action,
6824                                                          const char *name,
6825                                                          void *priv),
6826                                               void *priv)
6827 {
6828         struct tevent_req *req, *subreq;
6829         struct swallow_notify_state *state;
6830
6831         req = tevent_req_create(mem_ctx, &state,
6832                                 struct swallow_notify_state);
6833         if (req == NULL) {
6834                 return NULL;
6835         }
6836         state->ev = ev;
6837         state->cli = cli;
6838         state->fnum = fnum;
6839         state->completion_filter = completion_filter;
6840         state->recursive = recursive;
6841         state->fn = fn;
6842         state->priv = priv;
6843
6844         subreq = cli_notify_send(state, state->ev, state->cli, state->fnum,
6845                                  0xffff, state->completion_filter,
6846                                  state->recursive);
6847         if (tevent_req_nomem(subreq, req)) {
6848                 return tevent_req_post(req, ev);
6849         }
6850         tevent_req_set_callback(subreq, swallow_notify_done, req);
6851         return req;
6852 }
6853
6854 static void swallow_notify_done(struct tevent_req *subreq)
6855 {
6856         struct tevent_req *req = tevent_req_callback_data(
6857                 subreq, struct tevent_req);
6858         struct swallow_notify_state *state = tevent_req_data(
6859                 req, struct swallow_notify_state);
6860         NTSTATUS status;
6861         uint32_t i, num_changes;
6862         struct notify_change *changes;
6863
6864         status = cli_notify_recv(subreq, state, &num_changes, &changes);
6865         TALLOC_FREE(subreq);
6866         if (!NT_STATUS_IS_OK(status)) {
6867                 DEBUG(10, ("cli_notify_recv returned %s\n",
6868                            nt_errstr(status)));
6869                 tevent_req_nterror(req, status);
6870                 return;
6871         }
6872
6873         for (i=0; i<num_changes; i++) {
6874                 state->fn(changes[i].action, changes[i].name, state->priv);
6875         }
6876         TALLOC_FREE(changes);
6877
6878         subreq = cli_notify_send(state, state->ev, state->cli, state->fnum,
6879                                  0xffff, state->completion_filter,
6880                                  state->recursive);
6881         if (tevent_req_nomem(subreq, req)) {
6882                 return;
6883         }
6884         tevent_req_set_callback(subreq, swallow_notify_done, req);
6885 }
6886
6887 static bool print_notifies(uint32_t action, const char *name, void *priv)
6888 {
6889         if (DEBUGLEVEL > 5) {
6890                 d_printf("%d %s\n", (int)action, name);
6891         }
6892         return true;
6893 }
6894
6895 static void notify_bench_done(struct tevent_req *req)
6896 {
6897         int *num_finished = (int *)tevent_req_callback_data_void(req);
6898         *num_finished += 1;
6899 }
6900
6901 static bool run_notify_bench(int dummy)
6902 {
6903         const char *dname = "\\notify-bench";
6904         struct tevent_context *ev;
6905         NTSTATUS status;
6906         uint16_t dnum;
6907         struct tevent_req *req1;
6908         struct tevent_req *req2 = NULL;
6909         int i, num_unc_names;
6910         int num_finished = 0;
6911
6912         printf("starting notify-bench test\n");
6913
6914         if (use_multishare_conn) {
6915                 char **unc_list;
6916                 unc_list = file_lines_load(multishare_conn_fname,
6917                                            &num_unc_names, 0, NULL);
6918                 if (!unc_list || num_unc_names <= 0) {
6919                         d_printf("Failed to load unc names list from '%s'\n",
6920                                  multishare_conn_fname);
6921                         return false;
6922                 }
6923                 TALLOC_FREE(unc_list);
6924         } else {
6925                 num_unc_names = 1;
6926         }
6927
6928         ev = tevent_context_init(talloc_tos());
6929         if (ev == NULL) {
6930                 d_printf("tevent_context_init failed\n");
6931                 return false;
6932         }
6933
6934         for (i=0; i<num_unc_names; i++) {
6935                 struct cli_state *cli;
6936                 char *base_fname;
6937
6938                 base_fname = talloc_asprintf(talloc_tos(), "%s\\file%3.3d.",
6939                                              dname, i);
6940                 if (base_fname == NULL) {
6941                         return false;
6942                 }
6943
6944                 if (!torture_open_connection(&cli, i)) {
6945                         return false;
6946                 }
6947
6948                 status = cli_ntcreate(cli, dname, 0,
6949                                       MAXIMUM_ALLOWED_ACCESS,
6950                                       0, FILE_SHARE_READ|FILE_SHARE_WRITE|
6951                                       FILE_SHARE_DELETE,
6952                                       FILE_OPEN_IF, FILE_DIRECTORY_FILE, 0,
6953                                       &dnum);
6954
6955                 if (!NT_STATUS_IS_OK(status)) {
6956                         d_printf("Could not create %s: %s\n", dname,
6957                                  nt_errstr(status));
6958                         return false;
6959                 }
6960
6961                 req1 = swallow_notify_send(talloc_tos(), ev, cli, dnum,
6962                                            FILE_NOTIFY_CHANGE_FILE_NAME |
6963                                            FILE_NOTIFY_CHANGE_DIR_NAME |
6964                                            FILE_NOTIFY_CHANGE_ATTRIBUTES |
6965                                            FILE_NOTIFY_CHANGE_LAST_WRITE,
6966                                            false, print_notifies, NULL);
6967                 if (req1 == NULL) {
6968                         d_printf("Could not create notify request\n");
6969                         return false;
6970                 }
6971
6972                 req2 = torture_createdels_send(talloc_tos(), ev, cli,
6973                                                base_fname, 10, torture_numops);
6974                 if (req2 == NULL) {
6975                         d_printf("Could not create createdels request\n");
6976                         return false;
6977                 }
6978                 TALLOC_FREE(base_fname);
6979
6980                 tevent_req_set_callback(req2, notify_bench_done,
6981                                         &num_finished);
6982         }
6983
6984         while (num_finished < num_unc_names) {
6985                 int ret;
6986                 ret = tevent_loop_once(ev);
6987                 if (ret != 0) {
6988                         d_printf("tevent_loop_once failed\n");
6989                         return false;
6990                 }
6991         }
6992
6993         if (!tevent_req_poll(req2, ev)) {
6994                 d_printf("tevent_req_poll failed\n");
6995         }
6996
6997         status = torture_createdels_recv(req2);
6998         d_printf("torture_createdels_recv returned %s\n", nt_errstr(status));
6999
7000         return true;
7001 }
7002
7003 static bool run_mangle1(int dummy)
7004 {
7005         struct cli_state *cli;
7006         const char *fname = "this_is_a_long_fname_to_be_mangled.txt";
7007         uint16_t fnum;
7008         fstring alt_name;
7009         NTSTATUS status;
7010         time_t change_time, access_time, write_time;
7011         off_t size;
7012         uint16_t mode;
7013
7014         printf("starting mangle1 test\n");
7015         if (!torture_open_connection(&cli, 0)) {
7016                 return False;
7017         }
7018
7019         smbXcli_conn_set_sockopt(cli->conn, sockops);
7020
7021         status = cli_ntcreate(cli, fname, 0, GENERIC_ALL_ACCESS|DELETE_ACCESS,
7022                               FILE_ATTRIBUTE_NORMAL, 0, FILE_OVERWRITE_IF,
7023                               0, 0, &fnum);
7024         if (!NT_STATUS_IS_OK(status)) {
7025                 d_printf("open %s failed: %s\n", fname, nt_errstr(status));
7026                 return false;
7027         }
7028         cli_close(cli, fnum);
7029
7030         status = cli_qpathinfo_alt_name(cli, fname, alt_name);
7031         if (!NT_STATUS_IS_OK(status)) {
7032                 d_printf("cli_qpathinfo_alt_name failed: %s\n",
7033                          nt_errstr(status));
7034                 return false;
7035         }
7036         d_printf("alt_name: %s\n", alt_name);
7037
7038         status = cli_openx(cli, alt_name, O_RDONLY, DENY_NONE, &fnum);
7039         if (!NT_STATUS_IS_OK(status)) {
7040                 d_printf("cli_openx(%s) failed: %s\n", alt_name,
7041                          nt_errstr(status));
7042                 return false;
7043         }
7044         cli_close(cli, fnum);
7045
7046         status = cli_qpathinfo1(cli, alt_name, &change_time, &access_time,
7047                                 &write_time, &size, &mode);
7048         if (!NT_STATUS_IS_OK(status)) {
7049                 d_printf("cli_qpathinfo1(%s) failed: %s\n", alt_name,
7050                          nt_errstr(status));
7051                 return false;
7052         }
7053
7054         return true;
7055 }
7056
7057 static size_t null_source(uint8_t *buf, size_t n, void *priv)
7058 {
7059         size_t *to_pull = (size_t *)priv;
7060         size_t thistime = *to_pull;
7061
7062         thistime = MIN(thistime, n);
7063         if (thistime == 0) {
7064                 return 0;
7065         }
7066
7067         memset(buf, 0, thistime);
7068         *to_pull -= thistime;
7069         return thistime;
7070 }
7071
7072 static bool run_windows_write(int dummy)
7073 {
7074         struct cli_state *cli1;
7075         uint16_t fnum;
7076         int i;
7077         bool ret = false;
7078         const char *fname = "\\writetest.txt";
7079         struct timeval start_time;
7080         double seconds;
7081         double kbytes;
7082         NTSTATUS status;
7083
7084         printf("starting windows_write test\n");
7085         if (!torture_open_connection(&cli1, 0)) {
7086                 return False;
7087         }
7088
7089         status = cli_openx(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum);
7090         if (!NT_STATUS_IS_OK(status)) {
7091                 printf("open failed (%s)\n", nt_errstr(status));
7092                 return False;
7093         }
7094
7095         smbXcli_conn_set_sockopt(cli1->conn, sockops);
7096
7097         start_time = timeval_current();
7098
7099         for (i=0; i<torture_numops; i++) {
7100                 uint8_t c = 0;
7101                 off_t start = i * torture_blocksize;
7102                 size_t to_pull = torture_blocksize - 1;
7103
7104                 status = cli_writeall(cli1, fnum, 0, &c,
7105                                       start + torture_blocksize - 1, 1, NULL);
7106                 if (!NT_STATUS_IS_OK(status)) {
7107                         printf("cli_write failed: %s\n", nt_errstr(status));
7108                         goto fail;
7109                 }
7110
7111                 status = cli_push(cli1, fnum, 0, i * torture_blocksize, torture_blocksize,
7112                                   null_source, &to_pull);
7113                 if (!NT_STATUS_IS_OK(status)) {
7114                         printf("cli_push returned: %s\n", nt_errstr(status));
7115                         goto fail;
7116                 }
7117         }
7118
7119         seconds = timeval_elapsed(&start_time);
7120         kbytes = (double)torture_blocksize * torture_numops;
7121         kbytes /= 1024;
7122
7123         printf("Wrote %d kbytes in %.2f seconds: %d kb/sec\n", (int)kbytes,
7124                (double)seconds, (int)(kbytes/seconds));
7125
7126         ret = true;
7127  fail:
7128         cli_close(cli1, fnum);
7129         cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
7130         torture_close_connection(cli1);
7131         return ret;
7132 }
7133
7134 static bool run_cli_echo(int dummy)
7135 {
7136         struct cli_state *cli;
7137         NTSTATUS status;
7138
7139         printf("starting cli_echo test\n");
7140         if (!torture_open_connection(&cli, 0)) {
7141                 return false;
7142         }
7143         smbXcli_conn_set_sockopt(cli->conn, sockops);
7144
7145         status = cli_echo(cli, 5, data_blob_const("hello", 5));
7146
7147         d_printf("cli_echo returned %s\n", nt_errstr(status));
7148
7149         torture_close_connection(cli);
7150         return NT_STATUS_IS_OK(status);
7151 }
7152
7153 static bool run_uid_regression_test(int dummy)
7154 {
7155         static struct cli_state *cli;
7156         int16_t old_vuid;
7157         int16_t old_cnum;
7158         bool correct = True;
7159         NTSTATUS status;
7160
7161         printf("starting uid regression test\n");
7162
7163         if (!torture_open_connection(&cli, 0)) {
7164                 return False;
7165         }
7166
7167         smbXcli_conn_set_sockopt(cli->conn, sockops);
7168
7169         /* Ok - now save then logoff our current user. */
7170         old_vuid = cli_state_get_uid(cli);
7171
7172         status = cli_ulogoff(cli);
7173         if (!NT_STATUS_IS_OK(status)) {
7174                 d_printf("(%s) cli_ulogoff failed: %s\n",
7175                          __location__, nt_errstr(status));
7176                 correct = false;
7177                 goto out;
7178         }
7179
7180         cli_state_set_uid(cli, old_vuid);
7181
7182         /* Try an operation. */
7183         status = cli_mkdir(cli, "\\uid_reg_test");
7184         if (NT_STATUS_IS_OK(status)) {
7185                 d_printf("(%s) cli_mkdir succeeded\n",
7186                          __location__);
7187                 correct = false;
7188                 goto out;
7189         } else {
7190                 /* Should be bad uid. */
7191                 if (!check_error(__LINE__, status, ERRSRV, ERRbaduid,
7192                                  NT_STATUS_USER_SESSION_DELETED)) {
7193                         correct = false;
7194                         goto out;
7195                 }
7196         }
7197
7198         old_cnum = cli_state_get_tid(cli);
7199
7200         /* Now try a SMBtdis with the invald vuid set to zero. */
7201         cli_state_set_uid(cli, 0);
7202
7203         /* This should succeed. */
7204         status = cli_tdis(cli);
7205
7206         if (NT_STATUS_IS_OK(status)) {
7207                 d_printf("First tdis with invalid vuid should succeed.\n");
7208         } else {
7209                 d_printf("First tdis failed (%s)\n", nt_errstr(status));
7210                 correct = false;
7211                 goto out;
7212         }
7213
7214         cli_state_set_uid(cli, old_vuid);
7215         cli_state_set_tid(cli, old_cnum);
7216
7217         /* This should fail. */
7218         status = cli_tdis(cli);
7219         if (NT_STATUS_IS_OK(status)) {
7220                 d_printf("Second tdis with invalid vuid should fail - succeeded instead !.\n");
7221                 correct = false;
7222                 goto out;
7223         } else {
7224                 /* Should be bad tid. */
7225                 if (!check_error(__LINE__, status, ERRSRV, ERRinvnid,
7226                                 NT_STATUS_NETWORK_NAME_DELETED)) {
7227                         correct = false;
7228                         goto out;
7229                 }
7230         }
7231
7232         cli_rmdir(cli, "\\uid_reg_test");
7233
7234   out:
7235
7236         cli_shutdown(cli);
7237         return correct;
7238 }
7239
7240
7241 static const char *illegal_chars = "*\\/?<>|\":";
7242 static char force_shortname_chars[] = " +,.[];=\177";
7243
7244 static NTSTATUS shortname_del_fn(const char *mnt, struct file_info *finfo,
7245                              const char *mask, void *state)
7246 {
7247         struct cli_state *pcli = (struct cli_state *)state;
7248         fstring fname;
7249         NTSTATUS status = NT_STATUS_OK;
7250
7251         slprintf(fname, sizeof(fname), "\\shortname\\%s", finfo->name);
7252
7253         if (strcmp(finfo->name, ".") == 0 || strcmp(finfo->name, "..") == 0)
7254                 return NT_STATUS_OK;
7255
7256         if (finfo->mode & FILE_ATTRIBUTE_DIRECTORY) {
7257                 status = cli_rmdir(pcli, fname);
7258                 if (!NT_STATUS_IS_OK(status)) {
7259                         printf("del_fn: failed to rmdir %s\n,", fname );
7260                 }
7261         } else {
7262                 status = cli_unlink(pcli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
7263                 if (!NT_STATUS_IS_OK(status)) {
7264                         printf("del_fn: failed to unlink %s\n,", fname );
7265                 }
7266         }
7267         return status;
7268 }
7269
7270 struct sn_state {
7271         int matched;
7272         int i;
7273         bool val;
7274 };
7275
7276 static NTSTATUS shortname_list_fn(const char *mnt, struct file_info *finfo,
7277                               const char *name, void *state)
7278 {
7279         struct sn_state *s = (struct sn_state  *)state;
7280         int i = s->i;
7281
7282 #if 0
7283         printf("shortname list: i = %d, name = |%s|, shortname = |%s|\n",
7284                 i, finfo->name, finfo->short_name);
7285 #endif
7286
7287         if (strchr(force_shortname_chars, i)) {
7288                 if (!finfo->short_name) {
7289                         /* Shortname not created when it should be. */
7290                         d_printf("(%s) ERROR: Shortname was not created for file %s containing %d\n",
7291                                 __location__, finfo->name, i);
7292                         s->val = true;
7293                 }
7294         } else if (finfo->short_name){
7295                 /* Shortname created when it should not be. */
7296                 d_printf("(%s) ERROR: Shortname %s was created for file %s\n",
7297                         __location__, finfo->short_name, finfo->name);
7298                 s->val = true;
7299         }
7300         s->matched += 1;
7301         return NT_STATUS_OK;
7302 }
7303
7304 static bool run_shortname_test(int dummy)
7305 {
7306         static struct cli_state *cli;
7307         bool correct = True;
7308         int i;
7309         struct sn_state s;
7310         char fname[40];
7311         NTSTATUS status;
7312
7313         printf("starting shortname test\n");
7314
7315         if (!torture_open_connection(&cli, 0)) {
7316                 return False;
7317         }
7318
7319         smbXcli_conn_set_sockopt(cli->conn, sockops);
7320
7321         cli_list(cli, "\\shortname\\*", 0, shortname_del_fn, cli);
7322         cli_list(cli, "\\shortname\\*", FILE_ATTRIBUTE_DIRECTORY, shortname_del_fn, cli);
7323         cli_rmdir(cli, "\\shortname");
7324
7325         status = cli_mkdir(cli, "\\shortname");
7326         if (!NT_STATUS_IS_OK(status)) {
7327                 d_printf("(%s) cli_mkdir of \\shortname failed: %s\n",
7328                         __location__, nt_errstr(status));
7329                 correct = false;
7330                 goto out;
7331         }
7332
7333         if (strlcpy(fname, "\\shortname\\", sizeof(fname)) >= sizeof(fname)) {
7334                 correct = false;
7335                 goto out;
7336         }
7337         if (strlcat(fname, "test .txt", sizeof(fname)) >= sizeof(fname)) {
7338                 correct = false;
7339                 goto out;
7340         }
7341
7342         s.val = false;
7343
7344         for (i = 32; i < 128; i++) {
7345                 uint16_t fnum = (uint16_t)-1;
7346
7347                 s.i = i;
7348
7349                 if (strchr(illegal_chars, i)) {
7350                         continue;
7351                 }
7352                 fname[15] = i;
7353
7354                 status = cli_ntcreate(cli, fname, 0, GENERIC_ALL_ACCESS, FILE_ATTRIBUTE_NORMAL,
7355                                    FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OVERWRITE_IF, 0, 0, &fnum);
7356                 if (!NT_STATUS_IS_OK(status)) {
7357                         d_printf("(%s) cli_nt_create of %s failed: %s\n",
7358                                 __location__, fname, nt_errstr(status));
7359                         correct = false;
7360                         goto out;
7361                 }
7362                 cli_close(cli, fnum);
7363
7364                 s.matched = 0;
7365                 status = cli_list(cli, "\\shortname\\test*.*", 0,
7366                                   shortname_list_fn, &s);
7367                 if (s.matched != 1) {
7368                         d_printf("(%s) failed to list %s: %s\n",
7369                                 __location__, fname, nt_errstr(status));
7370                         correct = false;
7371                         goto out;
7372                 }
7373
7374                 status = cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
7375                 if (!NT_STATUS_IS_OK(status)) {
7376                         d_printf("(%s) failed to delete %s: %s\n",
7377                                 __location__, fname, nt_errstr(status));
7378                         correct = false;
7379                         goto out;
7380                 }
7381
7382                 if (s.val) {
7383                         correct = false;
7384                         goto out;
7385                 }
7386         }
7387
7388   out:
7389
7390         cli_list(cli, "\\shortname\\*", 0, shortname_del_fn, cli);
7391         cli_list(cli, "\\shortname\\*", FILE_ATTRIBUTE_DIRECTORY, shortname_del_fn, cli);
7392         cli_rmdir(cli, "\\shortname");
7393         torture_close_connection(cli);
7394         return correct;
7395 }
7396
7397 static void pagedsearch_cb(struct tevent_req *req)
7398 {
7399         int rc;
7400         struct tldap_message *msg;
7401         char *dn;
7402
7403         rc = tldap_search_paged_recv(req, talloc_tos(), &msg);
7404         if (rc != TLDAP_SUCCESS) {
7405                 d_printf("tldap_search_paged_recv failed: %s\n",
7406                          tldap_err2string(rc));
7407                 return;
7408         }
7409         if (tldap_msg_type(msg) != TLDAP_RES_SEARCH_ENTRY) {
7410                 TALLOC_FREE(msg);
7411                 return;
7412         }
7413         if (!tldap_entry_dn(msg, &dn)) {
7414                 d_printf("tldap_entry_dn failed\n");
7415                 return;
7416         }
7417         d_printf("%s\n", dn);
7418         TALLOC_FREE(msg);
7419 }
7420
7421 static bool run_tldap(int dummy)
7422 {
7423         struct tldap_context *ld;
7424         int fd, rc;
7425         NTSTATUS status;
7426         struct sockaddr_storage addr;
7427         struct tevent_context *ev;
7428         struct tevent_req *req;
7429         char *basedn;
7430         const char *filter;
7431
7432         if (!resolve_name(host, &addr, 0, false)) {
7433                 d_printf("could not find host %s\n", host);
7434                 return false;
7435         }
7436         status = open_socket_out(&addr, 389, 9999, &fd);
7437         if (!NT_STATUS_IS_OK(status)) {
7438                 d_printf("open_socket_out failed: %s\n", nt_errstr(status));
7439                 return false;
7440         }
7441
7442         ld = tldap_context_create(talloc_tos(), fd);
7443         if (ld == NULL) {
7444                 close(fd);
7445                 d_printf("tldap_context_create failed\n");
7446                 return false;
7447         }
7448
7449         rc = tldap_fetch_rootdse(ld);
7450         if (rc != TLDAP_SUCCESS) {
7451                 d_printf("tldap_fetch_rootdse failed: %s\n",
7452                          tldap_errstr(talloc_tos(), ld, rc));
7453                 return false;
7454         }
7455
7456         basedn = tldap_talloc_single_attribute(
7457                 tldap_rootdse(ld), "defaultNamingContext", talloc_tos());
7458         if (basedn == NULL) {
7459                 d_printf("no defaultNamingContext\n");
7460                 return false;
7461         }
7462         d_printf("defaultNamingContext: %s\n", basedn);
7463
7464         ev = tevent_context_init(talloc_tos());
7465         if (ev == NULL) {
7466                 d_printf("tevent_context_init failed\n");
7467                 return false;
7468         }
7469
7470         req = tldap_search_paged_send(talloc_tos(), ev, ld, basedn,
7471                                       TLDAP_SCOPE_SUB, "(objectclass=*)",
7472                                       NULL, 0, 0,
7473                                       NULL, 0, NULL, 0, 0, 0, 0, 5);
7474         if (req == NULL) {
7475                 d_printf("tldap_search_paged_send failed\n");
7476                 return false;
7477         }
7478         tevent_req_set_callback(req, pagedsearch_cb, NULL);
7479
7480         tevent_req_poll(req, ev);
7481
7482         TALLOC_FREE(req);
7483
7484         /* test search filters against rootDSE */
7485         filter = "(&(|(name=samba)(nextRid<=10000000)(usnChanged>=10)(samba~=ambas)(!(name=s*m*a)))"
7486                    "(|(name:=samba)(name:dn:2.5.13.5:=samba)(:dn:2.5.13.5:=samba)(!(name=*samba))))";
7487
7488         rc = tldap_search(ld, "", TLDAP_SCOPE_BASE, filter,
7489                           NULL, 0, 0, NULL, 0, NULL, 0, 0, 0, 0,
7490                           talloc_tos(), NULL, NULL);
7491         if (rc != TLDAP_SUCCESS) {
7492                 d_printf("tldap_search with complex filter failed: %s\n",
7493                          tldap_errstr(talloc_tos(), ld, rc));
7494                 return false;
7495         }
7496
7497         TALLOC_FREE(ld);
7498         return true;
7499 }
7500
7501 /* Torture test to ensure no regression of :
7502 https://bugzilla.samba.org/show_bug.cgi?id=7084
7503 */
7504
7505 static bool run_dir_createtime(int dummy)
7506 {
7507         struct cli_state *cli;
7508         const char *dname = "\\testdir";
7509         const char *fname = "\\testdir\\testfile";
7510         NTSTATUS status;
7511         struct timespec create_time;
7512         struct timespec create_time1;
7513         uint16_t fnum;
7514         bool ret = false;
7515
7516         if (!torture_open_connection(&cli, 0)) {
7517                 return false;
7518         }
7519
7520         cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
7521         cli_rmdir(cli, dname);
7522
7523         status = cli_mkdir(cli, dname);
7524         if (!NT_STATUS_IS_OK(status)) {
7525                 printf("mkdir failed: %s\n", nt_errstr(status));
7526                 goto out;
7527         }
7528
7529         status = cli_qpathinfo2(cli, dname, &create_time, NULL, NULL, NULL,
7530                                 NULL, NULL, NULL);
7531         if (!NT_STATUS_IS_OK(status)) {
7532                 printf("cli_qpathinfo2 returned %s\n",
7533                        nt_errstr(status));
7534                 goto out;
7535         }
7536
7537         /* Sleep 3 seconds, then create a file. */
7538         sleep(3);
7539
7540         status = cli_openx(cli, fname, O_RDWR | O_CREAT | O_EXCL,
7541                          DENY_NONE, &fnum);
7542         if (!NT_STATUS_IS_OK(status)) {
7543                 printf("cli_openx failed: %s\n", nt_errstr(status));
7544                 goto out;
7545         }
7546
7547         status = cli_qpathinfo2(cli, dname, &create_time1, NULL, NULL, NULL,
7548                                 NULL, NULL, NULL);
7549         if (!NT_STATUS_IS_OK(status)) {
7550                 printf("cli_qpathinfo2 (2) returned %s\n",
7551                        nt_errstr(status));
7552                 goto out;
7553         }
7554
7555         if (timespec_compare(&create_time1, &create_time)) {
7556                 printf("run_dir_createtime: create time was updated (error)\n");
7557         } else {
7558                 printf("run_dir_createtime: create time was not updated (correct)\n");
7559                 ret = true;
7560         }
7561
7562   out:
7563
7564         cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
7565         cli_rmdir(cli, dname);
7566         if (!torture_close_connection(cli)) {
7567                 ret = false;
7568         }
7569         return ret;
7570 }
7571
7572
7573 static bool run_streamerror(int dummy)
7574 {
7575         struct cli_state *cli;
7576         const char *dname = "\\testdir";
7577         const char *streamname =
7578                 "testdir:{4c8cc155-6c1e-11d1-8e41-00c04fb9386d}:$DATA";
7579         NTSTATUS status;
7580         time_t change_time, access_time, write_time;
7581         off_t size;
7582         uint16_t mode, fnum;
7583         bool ret = true;
7584
7585         if (!torture_open_connection(&cli, 0)) {
7586                 return false;
7587         }
7588
7589         cli_unlink(cli, "\\testdir\\*", FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
7590         cli_rmdir(cli, dname);
7591
7592         status = cli_mkdir(cli, dname);
7593         if (!NT_STATUS_IS_OK(status)) {
7594                 printf("mkdir failed: %s\n", nt_errstr(status));
7595                 return false;
7596         }
7597
7598         status = cli_qpathinfo1(cli, streamname, &change_time, &access_time,
7599                                 &write_time, &size, &mode);
7600         if (!NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
7601                 printf("pathinfo returned %s, expected "
7602                        "NT_STATUS_OBJECT_NAME_NOT_FOUND\n",
7603                        nt_errstr(status));
7604                 ret = false;
7605         }
7606
7607         status = cli_ntcreate(cli, streamname, 0x16,
7608                               FILE_READ_DATA|FILE_READ_EA|
7609                               FILE_READ_ATTRIBUTES|READ_CONTROL_ACCESS,
7610                               FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ,
7611                               FILE_OPEN, 0, 0, &fnum);
7612
7613         if (!NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
7614                 printf("ntcreate returned %s, expected "
7615                        "NT_STATUS_OBJECT_NAME_NOT_FOUND\n",
7616                        nt_errstr(status));
7617                 ret = false;
7618         }
7619
7620
7621         cli_rmdir(cli, dname);
7622         return ret;
7623 }
7624
7625 static bool run_local_substitute(int dummy)
7626 {
7627         bool ok = true;
7628
7629         ok &= subst_test("%U", "bla", "", -1, -1, "bla");
7630         ok &= subst_test("%u%U", "bla", "", -1, -1, "blabla");
7631         ok &= subst_test("%g", "", "", -1, -1, "NO_GROUP");
7632         ok &= subst_test("%G", "", "", -1, -1, "NO_GROUP");
7633         ok &= subst_test("%g", "", "", -1, 0, gidtoname(0));
7634         ok &= subst_test("%G", "", "", -1, 0, gidtoname(0));
7635         ok &= subst_test("%D%u", "u", "dom", -1, 0, "domu");
7636         ok &= subst_test("%i %I", "", "", -1, -1, "0.0.0.0 0.0.0.0");
7637
7638         /* Different captialization rules in sub_basic... */
7639
7640         ok &=  (strcmp(talloc_sub_basic(talloc_tos(), "BLA", "dom", "%U%D"),
7641                        "blaDOM") == 0);
7642
7643         return ok;
7644 }
7645
7646 static bool run_local_base64(int dummy)
7647 {
7648         int i;
7649         bool ret = true;
7650
7651         for (i=1; i<2000; i++) {
7652                 DATA_BLOB blob1, blob2;
7653                 char *b64;
7654
7655                 blob1.data = talloc_array(talloc_tos(), uint8_t, i);
7656                 blob1.length = i;
7657                 generate_random_buffer(blob1.data, blob1.length);
7658
7659                 b64 = base64_encode_data_blob(talloc_tos(), blob1);
7660                 if (b64 == NULL) {
7661                         d_fprintf(stderr, "base64_encode_data_blob failed "
7662                                   "for %d bytes\n", i);
7663                         ret = false;
7664                 }
7665                 blob2 = base64_decode_data_blob(b64);
7666                 TALLOC_FREE(b64);
7667
7668                 if (data_blob_cmp(&blob1, &blob2)) {
7669                         d_fprintf(stderr, "data_blob_cmp failed for %d "
7670                                   "bytes\n", i);
7671                         ret = false;
7672                 }
7673                 TALLOC_FREE(blob1.data);
7674                 data_blob_free(&blob2);
7675         }
7676         return ret;
7677 }
7678
7679 static bool run_local_gencache(int dummy)
7680 {
7681         char *val;
7682         time_t tm;
7683         DATA_BLOB blob;
7684
7685         if (!gencache_set("foo", "bar", time(NULL) + 1000)) {
7686                 d_printf("%s: gencache_set() failed\n", __location__);
7687                 return False;
7688         }
7689
7690         if (!gencache_get("foo", NULL, NULL)) {
7691                 d_printf("%s: gencache_get() failed\n", __location__);
7692                 return False;
7693         }
7694
7695         if (!gencache_get("foo", &val, &tm)) {
7696                 d_printf("%s: gencache_get() failed\n", __location__);
7697                 return False;
7698         }
7699
7700         if (strcmp(val, "bar") != 0) {
7701                 d_printf("%s: gencache_get() returned %s, expected %s\n",
7702                          __location__, val, "bar");
7703                 SAFE_FREE(val);
7704                 return False;
7705         }
7706
7707         SAFE_FREE(val);
7708
7709         if (!gencache_del("foo")) {
7710                 d_printf("%s: gencache_del() failed\n", __location__);
7711                 return False;
7712         }
7713         if (gencache_del("foo")) {
7714                 d_printf("%s: second gencache_del() succeeded\n",
7715                          __location__);
7716                 return False;
7717         }
7718
7719         if (gencache_get("foo", &val, &tm)) {
7720                 d_printf("%s: gencache_get() on deleted entry "
7721                          "succeeded\n", __location__);
7722                 return False;
7723         }
7724
7725         blob = data_blob_string_const_null("bar");
7726         tm = time(NULL) + 60;
7727
7728         if (!gencache_set_data_blob("foo", &blob, tm)) {
7729                 d_printf("%s: gencache_set_data_blob() failed\n", __location__);
7730                 return False;
7731         }
7732
7733         if (!gencache_get_data_blob("foo", &blob, NULL, NULL)) {
7734                 d_printf("%s: gencache_get_data_blob() failed\n", __location__);
7735                 return False;
7736         }
7737
7738         if (strcmp((const char *)blob.data, "bar") != 0) {
7739                 d_printf("%s: gencache_get_data_blob() returned %s, expected %s\n",
7740                          __location__, (const char *)blob.data, "bar");
7741                 data_blob_free(&blob);
7742                 return False;
7743         }
7744
7745         data_blob_free(&blob);
7746
7747         if (!gencache_del("foo")) {
7748                 d_printf("%s: gencache_del() failed\n", __location__);
7749                 return False;
7750         }
7751         if (gencache_del("foo")) {
7752                 d_printf("%s: second gencache_del() succeeded\n",
7753                          __location__);
7754                 return False;
7755         }
7756
7757         if (gencache_get_data_blob("foo", &blob, NULL, NULL)) {
7758                 d_printf("%s: gencache_get_data_blob() on deleted entry "
7759                          "succeeded\n", __location__);
7760                 return False;
7761         }
7762
7763         return True;
7764 }
7765
7766 static bool rbt_testval(struct db_context *db, const char *key,
7767                         const char *value)
7768 {
7769         struct db_record *rec;
7770         TDB_DATA data = string_tdb_data(value);
7771         bool ret = false;
7772         NTSTATUS status;
7773         TDB_DATA dbvalue;
7774
7775         rec = dbwrap_fetch_locked(db, db, string_tdb_data(key));
7776         if (rec == NULL) {
7777                 d_fprintf(stderr, "fetch_locked failed\n");
7778                 goto done;
7779         }
7780         status = dbwrap_record_store(rec, data, 0);
7781         if (!NT_STATUS_IS_OK(status)) {
7782                 d_fprintf(stderr, "store failed: %s\n", nt_errstr(status));
7783                 goto done;
7784         }
7785         TALLOC_FREE(rec);
7786
7787         rec = dbwrap_fetch_locked(db, db, string_tdb_data(key));
7788         if (rec == NULL) {
7789                 d_fprintf(stderr, "second fetch_locked failed\n");
7790                 goto done;
7791         }
7792
7793         dbvalue = dbwrap_record_get_value(rec);
7794         if ((dbvalue.dsize != data.dsize)
7795             || (memcmp(dbvalue.dptr, data.dptr, data.dsize) != 0)) {
7796                 d_fprintf(stderr, "Got wrong data back\n");
7797                 goto done;
7798         }
7799
7800         ret = true;
7801  done:
7802         TALLOC_FREE(rec);
7803         return ret;
7804 }
7805
7806 static bool run_local_rbtree(int dummy)
7807 {
7808         struct db_context *db;
7809         bool ret = false;
7810         int i;
7811
7812         db = db_open_rbt(NULL);
7813
7814         if (db == NULL) {
7815                 d_fprintf(stderr, "db_open_rbt failed\n");
7816                 return false;
7817         }
7818
7819         for (i=0; i<1000; i++) {
7820                 char *key, *value;
7821
7822                 if (asprintf(&key, "key%ld", random()) == -1) {
7823                         goto done;
7824                 }
7825                 if (asprintf(&value, "value%ld", random()) == -1) {
7826                         SAFE_FREE(key);
7827                         goto done;
7828                 }
7829
7830                 if (!rbt_testval(db, key, value)) {
7831                         SAFE_FREE(key);
7832                         SAFE_FREE(value);
7833                         goto done;
7834                 }
7835
7836                 SAFE_FREE(value);
7837                 if (asprintf(&value, "value%ld", random()) == -1) {
7838                         SAFE_FREE(key);
7839                         goto done;
7840                 }
7841
7842                 if (!rbt_testval(db, key, value)) {
7843                         SAFE_FREE(key);
7844                         SAFE_FREE(value);
7845                         goto done;
7846                 }
7847
7848                 SAFE_FREE(key);
7849                 SAFE_FREE(value);
7850         }
7851
7852         ret = true;
7853
7854  done:
7855         TALLOC_FREE(db);
7856         return ret;
7857 }
7858
7859
7860 /*
7861   local test for character set functions
7862
7863   This is a very simple test for the functionality in convert_string_error()
7864  */
7865 static bool run_local_convert_string(int dummy)
7866 {
7867         TALLOC_CTX *tmp_ctx = talloc_new(NULL);
7868         const char *test_strings[2] = { "March", "M\303\244rz" };
7869         char dst[7];
7870         int i;
7871
7872         for (i=0; i<2; i++) {
7873                 const char *str = test_strings[i];
7874                 int len = strlen(str);
7875                 size_t converted_size;
7876                 bool ret;
7877
7878                 memset(dst, 'X', sizeof(dst));
7879
7880                 /* first try with real source length */
7881                 ret = convert_string_error(CH_UNIX, CH_UTF8,
7882                                            str, len,
7883                                            dst, sizeof(dst),
7884                                            &converted_size);
7885                 if (ret != true) {
7886                         d_fprintf(stderr, "Failed to convert '%s' to CH_DISPLAY\n", str);
7887                         goto failed;
7888                 }
7889
7890                 if (converted_size != len) {
7891                         d_fprintf(stderr, "Converted size of '%s' should be %d - got %d\n",
7892                                   str, len, (int)converted_size);
7893                         goto failed;
7894                 }
7895
7896                 if (strncmp(str, dst, converted_size) != 0) {
7897                         d_fprintf(stderr, "Expected '%s' to match '%s'\n", str, dst);
7898                         goto failed;
7899                 }
7900
7901                 if (strlen(str) != converted_size) {
7902                         d_fprintf(stderr, "Expected '%s' length %d - got %d\n", str,
7903                                   (int)strlen(str), (int)converted_size);
7904                         goto failed;
7905                 }
7906
7907                 if (dst[converted_size] != 'X') {
7908                         d_fprintf(stderr, "Expected no termination of '%s'\n", dst);
7909                         goto failed;
7910                 }
7911
7912                 /* now with srclen==-1, this causes the nul to be
7913                  * converted too */
7914                 ret = convert_string_error(CH_UNIX, CH_UTF8,
7915                                            str, -1,
7916                                            dst, sizeof(dst),
7917                                            &converted_size);
7918                 if (ret != true) {
7919                         d_fprintf(stderr, "Failed to convert '%s' to CH_DISPLAY\n", str);
7920                         goto failed;
7921                 }
7922
7923                 if (converted_size != len+1) {
7924                         d_fprintf(stderr, "Converted size of '%s' should be %d - got %d\n",
7925                                   str, len, (int)converted_size);
7926                         goto failed;
7927                 }
7928
7929                 if (strncmp(str, dst, converted_size) != 0) {
7930                         d_fprintf(stderr, "Expected '%s' to match '%s'\n", str, dst);
7931                         goto failed;
7932                 }
7933
7934                 if (len+1 != converted_size) {
7935                         d_fprintf(stderr, "Expected '%s' length %d - got %d\n", str,
7936                                   len+1, (int)converted_size);
7937                         goto failed;
7938                 }
7939
7940                 if (dst[converted_size] != 'X') {
7941                         d_fprintf(stderr, "Expected no termination of '%s'\n", dst);
7942                         goto failed;
7943                 }
7944
7945         }
7946
7947
7948         TALLOC_FREE(tmp_ctx);
7949         return true;
7950 failed:
7951         TALLOC_FREE(tmp_ctx);
7952         return false;
7953 }
7954
7955
7956 struct talloc_dict_test {
7957         int content;
7958 };
7959
7960 static int talloc_dict_traverse_fn(DATA_BLOB key, void *data, void *priv)
7961 {
7962         int *count = (int *)priv;
7963         *count += 1;
7964         return 0;
7965 }
7966
7967 static bool run_local_talloc_dict(int dummy)
7968 {
7969         struct talloc_dict *dict;
7970         struct talloc_dict_test *t;
7971         int key, count, res;
7972         bool ok;
7973
7974         dict = talloc_dict_init(talloc_tos());
7975         if (dict == NULL) {
7976                 return false;
7977         }
7978
7979         t = talloc(talloc_tos(), struct talloc_dict_test);
7980         if (t == NULL) {
7981                 return false;
7982         }
7983
7984         key = 1;
7985         t->content = 1;
7986         ok = talloc_dict_set(dict, data_blob_const(&key, sizeof(key)), &t);
7987         if (!ok) {
7988                 return false;
7989         }
7990
7991         count = 0;
7992         res = talloc_dict_traverse(dict, talloc_dict_traverse_fn, &count);
7993         if (res == -1) {
7994                 return false;
7995         }
7996
7997         if (count != 1) {
7998                 return false;
7999         }
8000
8001         if (count != res) {
8002                 return false;
8003         }
8004
8005         TALLOC_FREE(dict);
8006
8007         return true;
8008 }
8009
8010 static bool run_local_string_to_sid(int dummy) {
8011         struct dom_sid sid;
8012
8013         if (string_to_sid(&sid, "S--1-5-32-545")) {
8014                 printf("allowing S--1-5-32-545\n");
8015                 return false;
8016         }
8017         if (string_to_sid(&sid, "S-1-5-32-+545")) {
8018                 printf("allowing S-1-5-32-+545\n");
8019                 return false;
8020         }
8021         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")) {
8022                 printf("allowing S-1-2-3-4-5-6-7-8-9-0-1-2-3-4-5-6-7-8-9-0\n");
8023                 return false;
8024         }
8025         if (string_to_sid(&sid, "S-1-5-32-545-abc")) {
8026                 printf("allowing S-1-5-32-545-abc\n");
8027                 return false;
8028         }
8029         if (!string_to_sid(&sid, "S-1-5-32-545")) {
8030                 printf("could not parse S-1-5-32-545\n");
8031                 return false;
8032         }
8033         if (!dom_sid_equal(&sid, &global_sid_Builtin_Users)) {
8034                 printf("mis-parsed S-1-5-32-545 as %s\n",
8035                        sid_string_tos(&sid));
8036                 return false;
8037         }
8038         return true;
8039 }
8040
8041 static bool run_local_binary_to_sid(int dummy) {
8042         struct dom_sid *sid = talloc(NULL, struct dom_sid);
8043         static const char good_binary_sid[] = {
8044                 0x1, /* revision number */
8045                 15, /* num auths */
8046                 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, /* id_auth */
8047                 0x1, 0x1, 0x1, 0x1, /* auth[0] */
8048                 0x1, 0x1, 0x1, 0x1, /* auth[1] */
8049                 0x1, 0x1, 0x1, 0x1, /* auth[2] */
8050                 0x1, 0x1, 0x1, 0x1, /* auth[3] */
8051                 0x1, 0x1, 0x1, 0x1, /* auth[4] */
8052                 0x1, 0x1, 0x1, 0x1, /* auth[5] */
8053                 0x1, 0x1, 0x1, 0x1, /* auth[6] */
8054                 0x1, 0x1, 0x1, 0x1, /* auth[7] */
8055                 0x1, 0x1, 0x1, 0x1, /* auth[8] */
8056                 0x1, 0x1, 0x1, 0x1, /* auth[9] */
8057                 0x1, 0x1, 0x1, 0x1, /* auth[10] */
8058                 0x1, 0x1, 0x1, 0x1, /* auth[11] */
8059                 0x1, 0x1, 0x1, 0x1, /* auth[12] */
8060                 0x1, 0x1, 0x1, 0x1, /* auth[13] */
8061                 0x1, 0x1, 0x1, 0x1, /* auth[14] */
8062         };
8063
8064         static const char long_binary_sid[] = {
8065                 0x1, /* revision number */
8066                 15, /* num auths */
8067                 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, /* id_auth */
8068                 0x1, 0x1, 0x1, 0x1, /* auth[0] */
8069                 0x1, 0x1, 0x1, 0x1, /* auth[1] */
8070                 0x1, 0x1, 0x1, 0x1, /* auth[2] */
8071                 0x1, 0x1, 0x1, 0x1, /* auth[3] */
8072                 0x1, 0x1, 0x1, 0x1, /* auth[4] */
8073                 0x1, 0x1, 0x1, 0x1, /* auth[5] */
8074                 0x1, 0x1, 0x1, 0x1, /* auth[6] */
8075                 0x1, 0x1, 0x1, 0x1, /* auth[7] */
8076                 0x1, 0x1, 0x1, 0x1, /* auth[8] */
8077                 0x1, 0x1, 0x1, 0x1, /* auth[9] */
8078                 0x1, 0x1, 0x1, 0x1, /* auth[10] */
8079                 0x1, 0x1, 0x1, 0x1, /* auth[11] */
8080                 0x1, 0x1, 0x1, 0x1, /* auth[12] */
8081                 0x1, 0x1, 0x1, 0x1, /* auth[13] */
8082                 0x1, 0x1, 0x1, 0x1, /* auth[14] */
8083                 0x1, 0x1, 0x1, 0x1, /* auth[15] */
8084                 0x1, 0x1, 0x1, 0x1, /* auth[16] */
8085                 0x1, 0x1, 0x1, 0x1, /* auth[17] */
8086         };
8087
8088         static const char long_binary_sid2[] = {
8089                 0x1, /* revision number */
8090                 32, /* num auths */
8091                 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, /* id_auth */
8092                 0x1, 0x1, 0x1, 0x1, /* auth[0] */
8093                 0x1, 0x1, 0x1, 0x1, /* auth[1] */
8094                 0x1, 0x1, 0x1, 0x1, /* auth[2] */
8095                 0x1, 0x1, 0x1, 0x1, /* auth[3] */
8096                 0x1, 0x1, 0x1, 0x1, /* auth[4] */
8097                 0x1, 0x1, 0x1, 0x1, /* auth[5] */
8098                 0x1, 0x1, 0x1, 0x1, /* auth[6] */
8099                 0x1, 0x1, 0x1, 0x1, /* auth[7] */
8100                 0x1, 0x1, 0x1, 0x1, /* auth[8] */
8101                 0x1, 0x1, 0x1, 0x1, /* auth[9] */
8102                 0x1, 0x1, 0x1, 0x1, /* auth[10] */
8103                 0x1, 0x1, 0x1, 0x1, /* auth[11] */
8104                 0x1, 0x1, 0x1, 0x1, /* auth[12] */
8105                 0x1, 0x1, 0x1, 0x1, /* auth[13] */
8106                 0x1, 0x1, 0x1, 0x1, /* auth[14] */
8107                 0x1, 0x1, 0x1, 0x1, /* auth[15] */
8108                 0x1, 0x1, 0x1, 0x1, /* auth[16] */
8109                 0x1, 0x1, 0x1, 0x1, /* auth[17] */
8110                 0x1, 0x1, 0x1, 0x1, /* auth[18] */
8111                 0x1, 0x1, 0x1, 0x1, /* auth[19] */
8112                 0x1, 0x1, 0x1, 0x1, /* auth[20] */
8113                 0x1, 0x1, 0x1, 0x1, /* auth[21] */
8114                 0x1, 0x1, 0x1, 0x1, /* auth[22] */
8115                 0x1, 0x1, 0x1, 0x1, /* auth[23] */
8116                 0x1, 0x1, 0x1, 0x1, /* auth[24] */
8117                 0x1, 0x1, 0x1, 0x1, /* auth[25] */
8118                 0x1, 0x1, 0x1, 0x1, /* auth[26] */
8119                 0x1, 0x1, 0x1, 0x1, /* auth[27] */
8120                 0x1, 0x1, 0x1, 0x1, /* auth[28] */
8121                 0x1, 0x1, 0x1, 0x1, /* auth[29] */
8122                 0x1, 0x1, 0x1, 0x1, /* auth[30] */
8123                 0x1, 0x1, 0x1, 0x1, /* auth[31] */
8124         };
8125
8126         if (!sid_parse(good_binary_sid, sizeof(good_binary_sid), sid)) {
8127                 return false;
8128         }
8129         if (sid_parse(long_binary_sid2, sizeof(long_binary_sid2), sid)) {
8130                 return false;
8131         }
8132         if (sid_parse(long_binary_sid, sizeof(long_binary_sid), sid)) {
8133                 return false;
8134         }
8135         return true;
8136 }
8137
8138 /* Split a path name into filename and stream name components. Canonicalise
8139  * such that an implicit $DATA token is always explicit.
8140  *
8141  * The "specification" of this function can be found in the
8142  * run_local_stream_name() function in torture.c, I've tried those
8143  * combinations against a W2k3 server.
8144  */
8145
8146 static NTSTATUS split_ntfs_stream_name(TALLOC_CTX *mem_ctx, const char *fname,
8147                                        char **pbase, char **pstream)
8148 {
8149         char *base = NULL;
8150         char *stream = NULL;
8151         char *sname; /* stream name */
8152         const char *stype; /* stream type */
8153
8154         DEBUG(10, ("split_ntfs_stream_name called for [%s]\n", fname));
8155
8156         sname = strchr_m(fname, ':');
8157
8158         if (lp_posix_pathnames() || (sname == NULL)) {
8159                 if (pbase != NULL) {
8160                         base = talloc_strdup(mem_ctx, fname);
8161                         NT_STATUS_HAVE_NO_MEMORY(base);
8162                 }
8163                 goto done;
8164         }
8165
8166         if (pbase != NULL) {
8167                 base = talloc_strndup(mem_ctx, fname, PTR_DIFF(sname, fname));
8168                 NT_STATUS_HAVE_NO_MEMORY(base);
8169         }
8170
8171         sname += 1;
8172
8173         stype = strchr_m(sname, ':');
8174
8175         if (stype == NULL) {
8176                 sname = talloc_strdup(mem_ctx, sname);
8177                 stype = "$DATA";
8178         }
8179         else {
8180                 if (strcasecmp_m(stype, ":$DATA") != 0) {
8181                         /*
8182                          * If there is an explicit stream type, so far we only
8183                          * allow $DATA. Is there anything else allowed? -- vl
8184                          */
8185                         DEBUG(10, ("[%s] is an invalid stream type\n", stype));
8186                         TALLOC_FREE(base);
8187                         return NT_STATUS_OBJECT_NAME_INVALID;
8188                 }
8189                 sname = talloc_strndup(mem_ctx, sname, PTR_DIFF(stype, sname));
8190                 stype += 1;
8191         }
8192
8193         if (sname == NULL) {
8194                 TALLOC_FREE(base);
8195                 return NT_STATUS_NO_MEMORY;
8196         }
8197
8198         if (sname[0] == '\0') {
8199                 /*
8200                  * no stream name, so no stream
8201                  */
8202                 goto done;
8203         }
8204
8205         if (pstream != NULL) {
8206                 stream = talloc_asprintf(mem_ctx, "%s:%s", sname, stype);
8207                 if (stream == NULL) {
8208                         TALLOC_FREE(sname);
8209                         TALLOC_FREE(base);
8210                         return NT_STATUS_NO_MEMORY;
8211                 }
8212                 /*
8213                  * upper-case the type field
8214                  */
8215                 strupper_m(strchr_m(stream, ':')+1);
8216         }
8217
8218  done:
8219         if (pbase != NULL) {
8220                 *pbase = base;
8221         }
8222         if (pstream != NULL) {
8223                 *pstream = stream;
8224         }
8225         return NT_STATUS_OK;
8226 }
8227
8228 static bool test_stream_name(const char *fname, const char *expected_base,
8229                              const char *expected_stream,
8230                              NTSTATUS expected_status)
8231 {
8232         NTSTATUS status;
8233         char *base = NULL;
8234         char *stream = NULL;
8235
8236         status = split_ntfs_stream_name(talloc_tos(), fname, &base, &stream);
8237         if (!NT_STATUS_EQUAL(status, expected_status)) {
8238                 goto error;
8239         }
8240
8241         if (!NT_STATUS_IS_OK(status)) {
8242                 return true;
8243         }
8244
8245         if (base == NULL) goto error;
8246
8247         if (strcmp(expected_base, base) != 0) goto error;
8248
8249         if ((expected_stream != NULL) && (stream == NULL)) goto error;
8250         if ((expected_stream == NULL) && (stream != NULL)) goto error;
8251
8252         if ((stream != NULL) && (strcmp(expected_stream, stream) != 0))
8253                 goto error;
8254
8255         TALLOC_FREE(base);
8256         TALLOC_FREE(stream);
8257         return true;
8258
8259  error:
8260         d_fprintf(stderr, "Do test_stream(%s, %s, %s, %s)\n",
8261                   fname, expected_base ? expected_base : "<NULL>",
8262                   expected_stream ? expected_stream : "<NULL>",
8263                   nt_errstr(expected_status));
8264         d_fprintf(stderr, "-> base=%s, stream=%s, status=%s\n",
8265                   base ? base : "<NULL>", stream ? stream : "<NULL>",
8266                   nt_errstr(status));
8267         TALLOC_FREE(base);
8268         TALLOC_FREE(stream);
8269         return false;
8270 }
8271
8272 static bool run_local_stream_name(int dummy)
8273 {
8274         bool ret = true;
8275
8276         ret &= test_stream_name(
8277                 "bla", "bla", NULL, NT_STATUS_OK);
8278         ret &= test_stream_name(
8279                 "bla::$DATA", "bla", NULL, NT_STATUS_OK);
8280         ret &= test_stream_name(
8281                 "bla:blub:", "bla", NULL, NT_STATUS_OBJECT_NAME_INVALID);
8282         ret &= test_stream_name(
8283                 "bla::", NULL, NULL, NT_STATUS_OBJECT_NAME_INVALID);
8284         ret &= test_stream_name(
8285                 "bla::123", "bla", NULL, NT_STATUS_OBJECT_NAME_INVALID);
8286         ret &= test_stream_name(
8287                 "bla:$DATA", "bla", "$DATA:$DATA", NT_STATUS_OK);
8288         ret &= test_stream_name(
8289                 "bla:x:$DATA", "bla", "x:$DATA", NT_STATUS_OK);
8290         ret &= test_stream_name(
8291                 "bla:x", "bla", "x:$DATA", NT_STATUS_OK);
8292
8293         return ret;
8294 }
8295
8296 static bool data_blob_equal(DATA_BLOB a, DATA_BLOB b)
8297 {
8298         if (a.length != b.length) {
8299                 printf("a.length=%d != b.length=%d\n",
8300                        (int)a.length, (int)b.length);
8301                 return false;
8302         }
8303         if (memcmp(a.data, b.data, a.length) != 0) {
8304                 printf("a.data and b.data differ\n");
8305                 return false;
8306         }
8307         return true;
8308 }
8309
8310 static bool run_local_memcache(int dummy)
8311 {
8312         struct memcache *cache;
8313         DATA_BLOB k1, k2;
8314         DATA_BLOB d1, d2, d3;
8315         DATA_BLOB v1, v2, v3;
8316
8317         TALLOC_CTX *mem_ctx;
8318         char *str1, *str2;
8319         size_t size1, size2;
8320         bool ret = false;
8321
8322         cache = memcache_init(NULL, sizeof(void *) == 8 ? 200 : 100);
8323
8324         if (cache == NULL) {
8325                 printf("memcache_init failed\n");
8326                 return false;
8327         }
8328
8329         d1 = data_blob_const("d1", 2);
8330         d2 = data_blob_const("d2", 2);
8331         d3 = data_blob_const("d3", 2);
8332
8333         k1 = data_blob_const("d1", 2);
8334         k2 = data_blob_const("d2", 2);
8335
8336         memcache_add(cache, STAT_CACHE, k1, d1);
8337         memcache_add(cache, GETWD_CACHE, k2, d2);
8338
8339         if (!memcache_lookup(cache, STAT_CACHE, k1, &v1)) {
8340                 printf("could not find k1\n");
8341                 return false;
8342         }
8343         if (!data_blob_equal(d1, v1)) {
8344                 return false;
8345         }
8346
8347         if (!memcache_lookup(cache, GETWD_CACHE, k2, &v2)) {
8348                 printf("could not find k2\n");
8349                 return false;
8350         }
8351         if (!data_blob_equal(d2, v2)) {
8352                 return false;
8353         }
8354
8355         memcache_add(cache, STAT_CACHE, k1, d3);
8356
8357         if (!memcache_lookup(cache, STAT_CACHE, k1, &v3)) {
8358                 printf("could not find replaced k1\n");
8359                 return false;
8360         }
8361         if (!data_blob_equal(d3, v3)) {
8362                 return false;
8363         }
8364
8365         memcache_add(cache, GETWD_CACHE, k1, d1);
8366
8367         if (memcache_lookup(cache, GETWD_CACHE, k2, &v2)) {
8368                 printf("Did find k2, should have been purged\n");
8369                 return false;
8370         }
8371
8372         TALLOC_FREE(cache);
8373
8374         cache = memcache_init(NULL, 0);
8375
8376         mem_ctx = talloc_init("foo");
8377
8378         str1 = talloc_strdup(mem_ctx, "string1");
8379         str2 = talloc_strdup(mem_ctx, "string2");
8380
8381         memcache_add_talloc(cache, SINGLETON_CACHE_TALLOC,
8382                             data_blob_string_const("torture"), &str1);
8383         size1 = talloc_total_size(cache);
8384
8385         memcache_add_talloc(cache, SINGLETON_CACHE_TALLOC,
8386                             data_blob_string_const("torture"), &str2);
8387         size2 = talloc_total_size(cache);
8388
8389         printf("size1=%d, size2=%d\n", (int)size1, (int)size2);
8390
8391         if (size2 > size1) {
8392                 printf("memcache leaks memory!\n");
8393                 goto fail;
8394         }
8395
8396         ret = true;
8397  fail:
8398         TALLOC_FREE(cache);
8399         return ret;
8400 }
8401
8402 static void wbclient_done(struct tevent_req *req)
8403 {
8404         wbcErr wbc_err;
8405         struct winbindd_response *wb_resp;
8406         int *i = (int *)tevent_req_callback_data_void(req);
8407
8408         wbc_err = wb_trans_recv(req, req, &wb_resp);
8409         TALLOC_FREE(req);
8410         *i += 1;
8411         d_printf("wb_trans_recv %d returned %s\n", *i, wbcErrorString(wbc_err));
8412 }
8413
8414 static bool run_local_wbclient(int dummy)
8415 {
8416         struct event_context *ev;
8417         struct wb_context **wb_ctx;
8418         struct winbindd_request wb_req;
8419         bool result = false;
8420         int i, j;
8421
8422         BlockSignals(True, SIGPIPE);
8423
8424         ev = tevent_context_init_byname(talloc_tos(), "epoll");
8425         if (ev == NULL) {
8426                 goto fail;
8427         }
8428
8429         wb_ctx = talloc_array(ev, struct wb_context *, torture_nprocs);
8430         if (wb_ctx == NULL) {
8431                 goto fail;
8432         }
8433
8434         ZERO_STRUCT(wb_req);
8435         wb_req.cmd = WINBINDD_PING;
8436
8437         d_printf("torture_nprocs=%d, numops=%d\n", (int)torture_nprocs, (int)torture_numops);
8438
8439         for (i=0; i<torture_nprocs; i++) {
8440                 wb_ctx[i] = wb_context_init(ev, NULL);
8441                 if (wb_ctx[i] == NULL) {
8442                         goto fail;
8443                 }
8444                 for (j=0; j<torture_numops; j++) {
8445                         struct tevent_req *req;
8446                         req = wb_trans_send(ev, ev, wb_ctx[i],
8447                                             (j % 2) == 0, &wb_req);
8448                         if (req == NULL) {
8449                                 goto fail;
8450                         }
8451                         tevent_req_set_callback(req, wbclient_done, &i);
8452                 }
8453         }
8454
8455         i = 0;
8456
8457         while (i < torture_nprocs * torture_numops) {
8458                 tevent_loop_once(ev);
8459         }
8460
8461         result = true;
8462  fail:
8463         TALLOC_FREE(ev);
8464         return result;
8465 }
8466
8467 static void getaddrinfo_finished(struct tevent_req *req)
8468 {
8469         char *name = (char *)tevent_req_callback_data_void(req);
8470         struct addrinfo *ainfo;
8471         int res;
8472
8473         res = getaddrinfo_recv(req, &ainfo);
8474         if (res != 0) {
8475                 d_printf("gai(%s) returned %s\n", name, gai_strerror(res));
8476                 return;
8477         }
8478         d_printf("gai(%s) succeeded\n", name);
8479         freeaddrinfo(ainfo);
8480 }
8481
8482 static bool run_getaddrinfo_send(int dummy)
8483 {
8484         TALLOC_CTX *frame = talloc_stackframe();
8485         struct fncall_context *ctx;
8486         struct tevent_context *ev;
8487         bool result = false;
8488         const char *names[4] = { "www.samba.org", "notfound.samba.org",
8489                                  "www.slashdot.org", "heise.de" };
8490         struct tevent_req *reqs[4];
8491         int i;
8492
8493         ev = event_context_init(frame);
8494         if (ev == NULL) {
8495                 goto fail;
8496         }
8497
8498         ctx = fncall_context_init(frame, 4);
8499
8500         for (i=0; i<ARRAY_SIZE(names); i++) {
8501                 reqs[i] = getaddrinfo_send(frame, ev, ctx, names[i], NULL,
8502                                            NULL);
8503                 if (reqs[i] == NULL) {
8504                         goto fail;
8505                 }
8506                 tevent_req_set_callback(reqs[i], getaddrinfo_finished,
8507                                         discard_const_p(void, names[i]));
8508         }
8509
8510         for (i=0; i<ARRAY_SIZE(reqs); i++) {
8511                 tevent_loop_once(ev);
8512         }
8513
8514         result = true;
8515 fail:
8516         TALLOC_FREE(frame);
8517         return result;
8518 }
8519
8520 static bool dbtrans_inc(struct db_context *db)
8521 {
8522         struct db_record *rec;
8523         uint32_t val;
8524         bool ret = false;
8525         NTSTATUS status;
8526         TDB_DATA value;
8527
8528         rec = dbwrap_fetch_locked(db, db, string_term_tdb_data("transtest"));
8529         if (rec == NULL) {
8530                 printf(__location__ "fetch_lock failed\n");
8531                 return false;
8532         }
8533
8534         value = dbwrap_record_get_value(rec);
8535
8536         if (value.dsize != sizeof(uint32_t)) {
8537                 printf(__location__ "value.dsize = %d\n",
8538                        (int)value.dsize);
8539                 goto fail;
8540         }
8541
8542         memcpy(&val, value.dptr, sizeof(val));
8543         val += 1;
8544
8545         status = dbwrap_record_store(
8546                 rec, make_tdb_data((uint8_t *)&val, sizeof(val)), 0);
8547         if (!NT_STATUS_IS_OK(status)) {
8548                 printf(__location__ "store failed: %s\n",
8549                        nt_errstr(status));
8550                 goto fail;
8551         }
8552
8553         ret = true;
8554 fail:
8555         TALLOC_FREE(rec);
8556         return ret;
8557 }
8558
8559 static bool run_local_dbtrans(int dummy)
8560 {
8561         struct db_context *db;
8562         struct db_record *rec;
8563         NTSTATUS status;
8564         uint32_t initial;
8565         int res;
8566         TDB_DATA value;
8567
8568         db = db_open(talloc_tos(), "transtest.tdb", 0, TDB_DEFAULT,
8569                      O_RDWR|O_CREAT, 0600, DBWRAP_LOCK_ORDER_1);
8570         if (db == NULL) {
8571                 printf("Could not open transtest.db\n");
8572                 return false;
8573         }
8574
8575         res = dbwrap_transaction_start(db);
8576         if (res != 0) {
8577                 printf(__location__ "transaction_start failed\n");
8578                 return false;
8579         }
8580
8581         rec = dbwrap_fetch_locked(db, db, string_term_tdb_data("transtest"));
8582         if (rec == NULL) {
8583                 printf(__location__ "fetch_lock failed\n");
8584                 return false;
8585         }
8586
8587         value = dbwrap_record_get_value(rec);
8588
8589         if (value.dptr == NULL) {
8590                 initial = 0;
8591                 status = dbwrap_record_store(
8592                         rec, make_tdb_data((uint8_t *)&initial,
8593                                            sizeof(initial)),
8594                         0);
8595                 if (!NT_STATUS_IS_OK(status)) {
8596                         printf(__location__ "store returned %s\n",
8597                                nt_errstr(status));
8598                         return false;
8599                 }
8600         }
8601
8602         TALLOC_FREE(rec);
8603
8604         res = dbwrap_transaction_commit(db);
8605         if (res != 0) {
8606                 printf(__location__ "transaction_commit failed\n");
8607                 return false;
8608         }
8609
8610         while (true) {
8611                 uint32_t val, val2;
8612                 int i;
8613
8614                 res = dbwrap_transaction_start(db);
8615                 if (res != 0) {
8616                         printf(__location__ "transaction_start failed\n");
8617                         break;
8618                 }
8619
8620                 status = dbwrap_fetch_uint32_bystring(db, "transtest", &val);
8621                 if (!NT_STATUS_IS_OK(status)) {
8622                         printf(__location__ "dbwrap_fetch_uint32 failed: %s\n",
8623                                nt_errstr(status));
8624                         break;
8625                 }
8626
8627                 for (i=0; i<10; i++) {
8628                         if (!dbtrans_inc(db)) {
8629                                 return false;
8630                         }
8631                 }
8632
8633                 status = dbwrap_fetch_uint32_bystring(db, "transtest", &val2);
8634                 if (!NT_STATUS_IS_OK(status)) {
8635                         printf(__location__ "dbwrap_fetch_uint32 failed: %s\n",
8636                                nt_errstr(status));
8637                         break;
8638                 }
8639
8640                 if (val2 != val + 10) {
8641                         printf(__location__ "val=%d, val2=%d\n",
8642                                (int)val, (int)val2);
8643                         break;
8644                 }
8645
8646                 printf("val2=%d\r", val2);
8647
8648                 res = dbwrap_transaction_commit(db);
8649                 if (res != 0) {
8650                         printf(__location__ "transaction_commit failed\n");
8651                         break;
8652                 }
8653         }
8654
8655         TALLOC_FREE(db);
8656         return true;
8657 }
8658
8659 /*
8660  * Just a dummy test to be run under a debugger. There's no real way
8661  * to inspect the tevent_select specific function from outside of
8662  * tevent_select.c.
8663  */
8664
8665 static bool run_local_tevent_select(int dummy)
8666 {
8667         struct tevent_context *ev;
8668         struct tevent_fd *fd1, *fd2;
8669         bool result = false;
8670
8671         ev = tevent_context_init_byname(NULL, "select");
8672         if (ev == NULL) {
8673                 d_fprintf(stderr, "tevent_context_init_byname failed\n");
8674                 goto fail;
8675         }
8676
8677         fd1 = tevent_add_fd(ev, ev, 2, 0, NULL, NULL);
8678         if (fd1 == NULL) {
8679                 d_fprintf(stderr, "tevent_add_fd failed\n");
8680                 goto fail;
8681         }
8682         fd2 = tevent_add_fd(ev, ev, 3, 0, NULL, NULL);
8683         if (fd2 == NULL) {
8684                 d_fprintf(stderr, "tevent_add_fd failed\n");
8685                 goto fail;
8686         }
8687         TALLOC_FREE(fd2);
8688
8689         fd2 = tevent_add_fd(ev, ev, 1, 0, NULL, NULL);
8690         if (fd2 == NULL) {
8691                 d_fprintf(stderr, "tevent_add_fd failed\n");
8692                 goto fail;
8693         }
8694
8695         result = true;
8696 fail:
8697         TALLOC_FREE(ev);
8698         return result;
8699 }
8700
8701 static bool run_local_hex_encode_buf(int dummy)
8702 {
8703         char buf[17];
8704         uint8_t src[8];
8705         int i;
8706
8707         for (i=0; i<sizeof(src); i++) {
8708                 src[i] = i;
8709         }
8710         hex_encode_buf(buf, src, sizeof(src));
8711         if (strcmp(buf, "0001020304050607") != 0) {
8712                 return false;
8713         }
8714         hex_encode_buf(buf, NULL, 0);
8715         if (buf[0] != '\0') {
8716                 return false;
8717         }
8718         return true;
8719 }
8720
8721 static const char *remove_duplicate_addrs2_test_strings_vector[] = {
8722         "0.0.0.0",
8723         "::0",
8724         "1.2.3.1",
8725         "0.0.0.0",
8726         "0.0.0.0",
8727         "1.2.3.2",
8728         "1.2.3.3",
8729         "1.2.3.4",
8730         "1.2.3.5",
8731         "::0",
8732         "1.2.3.6",
8733         "1.2.3.7",
8734         "::0",
8735         "::0",
8736         "::0",
8737         "1.2.3.8",
8738         "1.2.3.9",
8739         "1.2.3.10",
8740         "1.2.3.11",
8741         "1.2.3.12",
8742         "1.2.3.13",
8743         "1001:1111:1111:1000:0:1111:1111:1111",
8744         "1.2.3.1",
8745         "1.2.3.2",
8746         "1.2.3.3",
8747         "1.2.3.12",
8748         "::0",
8749         "::0"
8750 };
8751
8752 static const char *remove_duplicate_addrs2_test_strings_result[] = {
8753         "1.2.3.1",
8754         "1.2.3.2",
8755         "1.2.3.3",
8756         "1.2.3.4",
8757         "1.2.3.5",
8758         "1.2.3.6",
8759         "1.2.3.7",
8760         "1.2.3.8",
8761         "1.2.3.9",
8762         "1.2.3.10",
8763         "1.2.3.11",
8764         "1.2.3.12",
8765         "1.2.3.13",
8766         "1001:1111:1111:1000:0:1111:1111:1111"
8767 };
8768
8769 static bool run_local_remove_duplicate_addrs2(int dummy)
8770 {
8771         struct ip_service test_vector[28];
8772         int count, i;
8773
8774         /* Construct the sockaddr_storage test vector. */
8775         for (i = 0; i < 28; i++) {
8776                 struct addrinfo hints;
8777                 struct addrinfo *res = NULL;
8778                 int ret;
8779
8780                 memset(&hints, '\0', sizeof(hints));
8781                 hints.ai_flags = AI_NUMERICHOST;
8782                 ret = getaddrinfo(remove_duplicate_addrs2_test_strings_vector[i],
8783                                 NULL,
8784                                 &hints,
8785                                 &res);
8786                 if (ret) {
8787                         fprintf(stderr, "getaddrinfo failed on [%s]\n",
8788                                 remove_duplicate_addrs2_test_strings_vector[i]);
8789                         return false;
8790                 }
8791                 memset(&test_vector[i], '\0', sizeof(test_vector[i]));
8792                 memcpy(&test_vector[i].ss,
8793                         res->ai_addr,
8794                         res->ai_addrlen);
8795                 freeaddrinfo(res);
8796         }
8797
8798         count = remove_duplicate_addrs2(test_vector, i);
8799
8800         if (count != 14) {
8801                 fprintf(stderr, "count wrong (%d) should be 14\n",
8802                         count);
8803                 return false;
8804         }
8805
8806         for (i = 0; i < count; i++) {
8807                 char addr[INET6_ADDRSTRLEN];
8808
8809                 print_sockaddr(addr, sizeof(addr), &test_vector[i].ss);
8810
8811                 if (strcmp(addr, remove_duplicate_addrs2_test_strings_result[i]) != 0) {
8812                         fprintf(stderr, "mismatch on [%d] [%s] [%s]\n",
8813                                 i,
8814                                 addr,
8815                                 remove_duplicate_addrs2_test_strings_result[i]);
8816                         return false;
8817                 }
8818         }
8819
8820         printf("run_local_remove_duplicate_addrs2: success\n");
8821         return true;
8822 }
8823
8824 static double create_procs(bool (*fn)(int), bool *result)
8825 {
8826         int i, status;
8827         volatile pid_t *child_status;
8828         volatile bool *child_status_out;
8829         int synccount;
8830         int tries = 8;
8831         struct timeval start;
8832
8833         synccount = 0;
8834
8835         child_status = (volatile pid_t *)anonymous_shared_allocate(sizeof(pid_t)*torture_nprocs);
8836         if (!child_status) {
8837                 printf("Failed to setup shared memory\n");
8838                 return -1;
8839         }
8840
8841         child_status_out = (volatile bool *)anonymous_shared_allocate(sizeof(bool)*torture_nprocs);
8842         if (!child_status_out) {
8843                 printf("Failed to setup result status shared memory\n");
8844                 return -1;
8845         }
8846
8847         for (i = 0; i < torture_nprocs; i++) {
8848                 child_status[i] = 0;
8849                 child_status_out[i] = True;
8850         }
8851
8852         start = timeval_current();
8853
8854         for (i=0;i<torture_nprocs;i++) {
8855                 procnum = i;
8856                 if (fork() == 0) {
8857                         pid_t mypid = getpid();
8858                         sys_srandom(((int)mypid) ^ ((int)time(NULL)));
8859
8860                         slprintf(myname,sizeof(myname),"CLIENT%d", i);
8861
8862                         while (1) {
8863                                 if (torture_open_connection(&current_cli, i)) break;
8864                                 if (tries-- == 0) {
8865                                         printf("pid %d failed to start\n", (int)getpid());
8866                                         _exit(1);
8867                                 }
8868                                 smb_msleep(10);
8869                         }
8870
8871                         child_status[i] = getpid();
8872
8873                         while (child_status[i] && timeval_elapsed(&start) < 5) smb_msleep(2);
8874
8875                         child_status_out[i] = fn(i);
8876                         _exit(0);
8877                 }
8878         }
8879
8880         do {
8881                 synccount = 0;
8882                 for (i=0;i<torture_nprocs;i++) {
8883                         if (child_status[i]) synccount++;
8884                 }
8885                 if (synccount == torture_nprocs) break;
8886                 smb_msleep(10);
8887         } while (timeval_elapsed(&start) < 30);
8888
8889         if (synccount != torture_nprocs) {
8890                 printf("FAILED TO START %d CLIENTS (started %d)\n", torture_nprocs, synccount);
8891                 *result = False;
8892                 return timeval_elapsed(&start);
8893         }
8894
8895         /* start the client load */
8896         start = timeval_current();
8897
8898         for (i=0;i<torture_nprocs;i++) {
8899                 child_status[i] = 0;
8900         }
8901
8902         printf("%d clients started\n", torture_nprocs);
8903
8904         for (i=0;i<torture_nprocs;i++) {
8905                 while (waitpid(0, &status, 0) == -1 && errno == EINTR) /* noop */ ;
8906         }
8907
8908         printf("\n");
8909
8910         for (i=0;i<torture_nprocs;i++) {
8911                 if (!child_status_out[i]) {
8912                         *result = False;
8913                 }
8914         }
8915         return timeval_elapsed(&start);
8916 }
8917
8918 #define FLAG_MULTIPROC 1
8919
8920 static struct {
8921         const char *name;
8922         bool (*fn)(int);
8923         unsigned flags;
8924 } torture_ops[] = {
8925         {"FDPASS", run_fdpasstest, 0},
8926         {"LOCK1",  run_locktest1,  0},
8927         {"LOCK2",  run_locktest2,  0},
8928         {"LOCK3",  run_locktest3,  0},
8929         {"LOCK4",  run_locktest4,  0},
8930         {"LOCK5",  run_locktest5,  0},
8931         {"LOCK6",  run_locktest6,  0},
8932         {"LOCK7",  run_locktest7,  0},
8933         {"LOCK8",  run_locktest8,  0},
8934         {"LOCK9",  run_locktest9,  0},
8935         {"UNLINK", run_unlinktest, 0},
8936         {"BROWSE", run_browsetest, 0},
8937         {"ATTR",   run_attrtest,   0},
8938         {"TRANS2", run_trans2test, 0},
8939         {"MAXFID", run_maxfidtest, FLAG_MULTIPROC},
8940         {"TORTURE",run_torture,    FLAG_MULTIPROC},
8941         {"RANDOMIPC", run_randomipc, 0},
8942         {"NEGNOWAIT", run_negprot_nowait, 0},
8943         {"NBENCH",  run_nbench, 0},
8944         {"NBENCH2", run_nbench2, 0},
8945         {"OPLOCK1",  run_oplock1, 0},
8946         {"OPLOCK2",  run_oplock2, 0},
8947         {"OPLOCK4",  run_oplock4, 0},
8948         {"DIR",  run_dirtest, 0},
8949         {"DIR1",  run_dirtest1, 0},
8950         {"DIR-CREATETIME",  run_dir_createtime, 0},
8951         {"DENY1",  torture_denytest1, 0},
8952         {"DENY2",  torture_denytest2, 0},
8953         {"TCON",  run_tcon_test, 0},
8954         {"TCONDEV",  run_tcon_devtype_test, 0},
8955         {"RW1",  run_readwritetest, 0},
8956         {"RW2",  run_readwritemulti, FLAG_MULTIPROC},
8957         {"RW3",  run_readwritelarge, 0},
8958         {"RW-SIGNING",  run_readwritelarge_signtest, 0},
8959         {"OPEN", run_opentest, 0},
8960         {"POSIX", run_simple_posix_open_test, 0},
8961         {"POSIX-APPEND", run_posix_append, 0},
8962         {"CASE-INSENSITIVE-CREATE", run_case_insensitive_create, 0},
8963         {"ASYNC-ECHO", run_async_echo, 0},
8964         { "UID-REGRESSION-TEST", run_uid_regression_test, 0},
8965         { "SHORTNAME-TEST", run_shortname_test, 0},
8966         { "ADDRCHANGE", run_addrchange, 0},
8967 #if 1
8968         {"OPENATTR", run_openattrtest, 0},
8969 #endif
8970         {"XCOPY", run_xcopy, 0},
8971         {"RENAME", run_rename, 0},
8972         {"DELETE", run_deletetest, 0},
8973         {"DELETE-LN", run_deletetest_ln, 0},
8974         {"PROPERTIES", run_properties, 0},
8975         {"MANGLE", torture_mangle, 0},
8976         {"MANGLE1", run_mangle1, 0},
8977         {"W2K", run_w2ktest, 0},
8978         {"TRANS2SCAN", torture_trans2_scan, 0},
8979         {"NTTRANSSCAN", torture_nttrans_scan, 0},
8980         {"UTABLE", torture_utable, 0},
8981         {"CASETABLE", torture_casetable, 0},
8982         {"ERRMAPEXTRACT", run_error_map_extract, 0},
8983         {"PIPE_NUMBER", run_pipe_number, 0},
8984         {"TCON2",  run_tcon2_test, 0},
8985         {"IOCTL",  torture_ioctl_test, 0},
8986         {"CHKPATH",  torture_chkpath_test, 0},
8987         {"FDSESS", run_fdsesstest, 0},
8988         { "EATEST", run_eatest, 0},
8989         { "SESSSETUP_BENCH", run_sesssetup_bench, 0},
8990         { "CHAIN1", run_chain1, 0},
8991         { "CHAIN2", run_chain2, 0},
8992         { "CHAIN3", run_chain3, 0},
8993         { "WINDOWS-WRITE", run_windows_write, 0},
8994         { "NTTRANS-CREATE", run_nttrans_create, 0},
8995         { "NTTRANS-FSCTL", run_nttrans_fsctl, 0},
8996         { "CLI_ECHO", run_cli_echo, 0},
8997         { "GETADDRINFO", run_getaddrinfo_send, 0},
8998         { "TLDAP", run_tldap },
8999         { "STREAMERROR", run_streamerror },
9000         { "NOTIFY-BENCH", run_notify_bench },
9001         { "NOTIFY-BENCH2", run_notify_bench2 },
9002         { "NOTIFY-BENCH3", run_notify_bench3 },
9003         { "BAD-NBT-SESSION", run_bad_nbt_session },
9004         { "SMB-ANY-CONNECT", run_smb_any_connect },
9005         { "NOTIFY-ONLINE", run_notify_online },
9006         { "SMB2-BASIC", run_smb2_basic },
9007         { "SMB2-NEGPROT", run_smb2_negprot },
9008         { "SMB2-SESSION-RECONNECT", run_smb2_session_reconnect },
9009         { "SMB2-TCON-DEPENDENCE", run_smb2_tcon_dependence },
9010         { "SMB2-MULTI-CHANNEL", run_smb2_multi_channel },
9011         { "SMB2-SESSION-REAUTH", run_smb2_session_reauth },
9012         { "CLEANUP1", run_cleanup1 },
9013         { "CLEANUP2", run_cleanup2 },
9014         { "CLEANUP3", run_cleanup3 },
9015         { "LOCAL-SUBSTITUTE", run_local_substitute, 0},
9016         { "LOCAL-GENCACHE", run_local_gencache, 0},
9017         { "LOCAL-TALLOC-DICT", run_local_talloc_dict, 0},
9018         { "LOCAL-CTDB-CONN", run_ctdb_conn, 0},
9019         { "LOCAL-MSG", run_msg_test, 0},
9020         { "LOCAL-DBWRAP-WATCH1", run_dbwrap_watch1, 0 },
9021         { "LOCAL-BASE64", run_local_base64, 0},
9022         { "LOCAL-RBTREE", run_local_rbtree, 0},
9023         { "LOCAL-MEMCACHE", run_local_memcache, 0},
9024         { "LOCAL-STREAM-NAME", run_local_stream_name, 0},
9025         { "LOCAL-WBCLIENT", run_local_wbclient, 0},
9026         { "LOCAL-string_to_sid", run_local_string_to_sid, 0},
9027         { "LOCAL-binary_to_sid", run_local_binary_to_sid, 0},
9028         { "LOCAL-DBTRANS", run_local_dbtrans, 0},
9029         { "LOCAL-TEVENT-SELECT", run_local_tevent_select, 0},
9030         { "LOCAL-CONVERT-STRING", run_local_convert_string, 0},
9031         { "LOCAL-CONV-AUTH-INFO", run_local_conv_auth_info, 0},
9032         { "LOCAL-sprintf_append", run_local_sprintf_append, 0},
9033         { "LOCAL-hex_encode_buf", run_local_hex_encode_buf, 0},
9034         { "LOCAL-IDMAP-TDB-COMMON", run_idmap_tdb_common_test, 0},
9035         { "LOCAL-remove_duplicate_addrs2", run_local_remove_duplicate_addrs2, 0},
9036         {NULL, NULL, 0}};
9037
9038
9039
9040 /****************************************************************************
9041 run a specified test or "ALL"
9042 ****************************************************************************/
9043 static bool run_test(const char *name)
9044 {
9045         bool ret = True;
9046         bool result = True;
9047         bool found = False;
9048         int i;
9049         double t;
9050         if (strequal(name,"ALL")) {
9051                 for (i=0;torture_ops[i].name;i++) {
9052                         run_test(torture_ops[i].name);
9053                 }
9054                 found = True;
9055         }
9056
9057         for (i=0;torture_ops[i].name;i++) {
9058                 fstr_sprintf(randomfname, "\\XX%x",
9059                          (unsigned)random());
9060
9061                 if (strequal(name, torture_ops[i].name)) {
9062                         found = True;
9063                         printf("Running %s\n", name);
9064                         if (torture_ops[i].flags & FLAG_MULTIPROC) {
9065                                 t = create_procs(torture_ops[i].fn, &result);
9066                                 if (!result) {
9067                                         ret = False;
9068                                         printf("TEST %s FAILED!\n", name);
9069                                 }
9070                         } else {
9071                                 struct timeval start;
9072                                 start = timeval_current();
9073                                 if (!torture_ops[i].fn(0)) {
9074                                         ret = False;
9075                                         printf("TEST %s FAILED!\n", name);
9076                                 }
9077                                 t = timeval_elapsed(&start);
9078                         }
9079                         printf("%s took %g secs\n\n", name, t);
9080                 }
9081         }
9082
9083         if (!found) {
9084                 printf("Did not find a test named %s\n", name);
9085                 ret = False;
9086         }
9087
9088         return ret;
9089 }
9090
9091
9092 static void usage(void)
9093 {
9094         int i;
9095
9096         printf("WARNING samba4 test suite is much more complete nowadays.\n");
9097         printf("Please use samba4 torture.\n\n");
9098
9099         printf("Usage: smbtorture //server/share <options> TEST1 TEST2 ...\n");
9100
9101         printf("\t-d debuglevel\n");
9102         printf("\t-U user%%pass\n");
9103         printf("\t-k               use kerberos\n");
9104         printf("\t-N numprocs\n");
9105         printf("\t-n my_netbios_name\n");
9106         printf("\t-W workgroup\n");
9107         printf("\t-o num_operations\n");
9108         printf("\t-O socket_options\n");
9109         printf("\t-m maximum protocol\n");
9110         printf("\t-L use oplocks\n");
9111         printf("\t-c CLIENT.TXT   specify client load file for NBENCH\n");
9112         printf("\t-A showall\n");
9113         printf("\t-p port\n");
9114         printf("\t-s seed\n");
9115         printf("\t-b unclist_filename   specify multiple shares for multiple connections\n");
9116         printf("\t-f filename   filename to test\n");
9117         printf("\n\n");
9118
9119         printf("tests are:");
9120         for (i=0;torture_ops[i].name;i++) {
9121                 printf(" %s", torture_ops[i].name);
9122         }
9123         printf("\n");
9124
9125         printf("default test is ALL\n");
9126
9127         exit(1);
9128 }
9129
9130 /****************************************************************************
9131   main program
9132 ****************************************************************************/
9133  int main(int argc,char *argv[])
9134 {
9135         int opt, i;
9136         char *p;
9137         int gotuser = 0;
9138         int gotpass = 0;
9139         bool correct = True;
9140         TALLOC_CTX *frame = talloc_stackframe();
9141         int seed = time(NULL);
9142
9143 #ifdef HAVE_SETBUFFER
9144         setbuffer(stdout, NULL, 0);
9145 #endif
9146
9147         setup_logging("smbtorture", DEBUG_STDOUT);
9148
9149         load_case_tables();
9150
9151         if (is_default_dyn_CONFIGFILE()) {
9152                 if(getenv("SMB_CONF_PATH")) {
9153                         set_dyn_CONFIGFILE(getenv("SMB_CONF_PATH"));
9154                 }
9155         }
9156         lp_load_global(get_dyn_CONFIGFILE());
9157         load_interfaces();
9158
9159         if (argc < 2) {
9160                 usage();
9161         }
9162
9163         for(p = argv[1]; *p; p++)
9164           if(*p == '\\')
9165             *p = '/';
9166
9167         if (strncmp(argv[1], "//", 2)) {
9168                 usage();
9169         }
9170
9171         fstrcpy(host, &argv[1][2]);
9172         p = strchr_m(&host[2],'/');
9173         if (!p) {
9174                 usage();
9175         }
9176         *p = 0;
9177         fstrcpy(share, p+1);
9178
9179         fstrcpy(myname, get_myname(talloc_tos()));
9180         if (!*myname) {
9181                 fprintf(stderr, "Failed to get my hostname.\n");
9182                 return 1;
9183         }
9184
9185         if (*username == 0 && getenv("LOGNAME")) {
9186           fstrcpy(username,getenv("LOGNAME"));
9187         }
9188
9189         argc--;
9190         argv++;
9191
9192         fstrcpy(workgroup, lp_workgroup());
9193
9194         while ((opt = getopt(argc, argv, "p:hW:U:n:N:O:o:m:Ll:d:Aec:ks:b:B:f:"))
9195                != EOF) {
9196                 switch (opt) {
9197                 case 'p':
9198                         port_to_use = atoi(optarg);
9199                         break;
9200                 case 's':
9201                         seed = atoi(optarg);
9202                         break;
9203                 case 'W':
9204                         fstrcpy(workgroup,optarg);
9205                         break;
9206                 case 'm':
9207                         max_protocol = interpret_protocol(optarg, max_protocol);
9208                         break;
9209                 case 'N':
9210                         torture_nprocs = atoi(optarg);
9211                         break;
9212                 case 'o':
9213                         torture_numops = atoi(optarg);
9214                         break;
9215                 case 'd':
9216                         lp_set_cmdline("log level", optarg);
9217                         break;
9218                 case 'O':
9219                         sockops = optarg;
9220                         break;
9221                 case 'L':
9222                         use_oplocks = True;
9223                         break;
9224                 case 'l':
9225                         local_path = optarg;
9226                         break;
9227                 case 'A':
9228                         torture_showall = True;
9229                         break;
9230                 case 'n':
9231                         fstrcpy(myname, optarg);
9232                         break;
9233                 case 'c':
9234                         client_txt = optarg;
9235                         break;
9236                 case 'e':
9237                         do_encrypt = true;
9238                         break;
9239                 case 'k':
9240 #ifdef HAVE_KRB5
9241                         use_kerberos = True;
9242 #else
9243                         d_printf("No kerberos support compiled in\n");
9244                         exit(1);
9245 #endif
9246                         break;
9247                 case 'U':
9248                         gotuser = 1;
9249                         fstrcpy(username,optarg);
9250                         p = strchr_m(username,'%');
9251                         if (p) {
9252                                 *p = 0;
9253                                 fstrcpy(password, p+1);
9254                                 gotpass = 1;
9255                         }
9256                         break;
9257                 case 'b':
9258                         fstrcpy(multishare_conn_fname, optarg);
9259                         use_multishare_conn = True;
9260                         break;
9261                 case 'B':
9262                         torture_blocksize = atoi(optarg);
9263                         break;
9264                 case 'f':
9265                         test_filename = SMB_STRDUP(optarg);
9266                         break;
9267                 default:
9268                         printf("Unknown option %c (%d)\n", (char)opt, opt);
9269                         usage();
9270                 }
9271         }
9272
9273         d_printf("using seed %d\n", seed);
9274
9275         srandom(seed);
9276
9277         if(use_kerberos && !gotuser) gotpass = True;
9278
9279         while (!gotpass) {
9280                 p = getpass("Password:");
9281                 if (p) {
9282                         fstrcpy(password, p);
9283                         gotpass = 1;
9284                 }
9285         }
9286
9287         printf("host=%s share=%s user=%s myname=%s\n",
9288                host, share, username, myname);
9289
9290         if (argc == optind) {
9291                 correct = run_test("ALL");
9292         } else {
9293                 for (i=optind;i<argc;i++) {
9294                         if (!run_test(argv[i])) {
9295                                 correct = False;
9296                         }
9297                 }
9298         }
9299
9300         TALLOC_FREE(frame);
9301
9302         if (correct) {
9303                 return(0);
9304         } else {
9305                 return(1);
9306         }
9307 }