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