source/utils/torture.c

   1 /*
   2    Unix SMB/Netbios implementation.
   3    Version 1.9.
   4    SMB torture tester
   5    Copyright (C) Andrew Tridgell 1997
   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 2 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, write to the Free Software
  19    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20 */
  21
  22 #ifdef SYSLOG
  23 #undef SYSLOG
  24 #endif
  25
  26 #include "includes.h"
  27
  28 static fstring host, workgroup, share, password, username, myname;
  29 static int max_protocol = PROTOCOL_NT1;
  30 static char *sockops="";
  31
  32
  33 static struct timeval tp1,tp2;
  34
  35 static void start_timer()
  36 {
  37         gettimeofday(&tp1,NULL);
  38 }
  39
  40 static double end_timer()
  41 {
  42         gettimeofday(&tp2,NULL);
  43         return((tp2.tv_sec - tp1.tv_sec) +
  44                (tp2.tv_usec - tp1.tv_usec)*1.0e-6);
  45 }
  46
  47
  48 static BOOL open_connection(struct cli_state *c)
  49 {
  50         if (!cli_initialise(c) || !cli_connect(c, host, NULL)) {
  51                 printf("Failed to connect with %s\n", host);
  52                 return False;
  53         }
  54
  55         if (!cli_session_request(c, host, 0x20, myname)) {
  56                 printf("%s rejected the session\n",host);
  57                 cli_shutdown(c);
  58                 return False;
  59         }
  60
  61         c->protocol = max_protocol;
  62
  63         if (!cli_negprot(c)) {
  64                 printf("%s rejected the negprot (%s)\n",host, cli_errstr(c));
  65                 cli_shutdown(c);
  66                 return False;
  67         }
  68
  69         if (!cli_session_setup(c, username, password, strlen(password),
  70                                "", 0, workgroup)) {
  71                 printf("%s rejected the sessionsetup (%s)\n", host, cli_errstr(c));
  72                 cli_shutdown(c);
  73                 return False;
  74         }
  75
  76         if (!cli_send_tconX(c, share, "A:", password, strlen(password)+1)) {
  77                 printf("%s refused tree connect (%s)\n", host, cli_errstr(c));
  78                 cli_shutdown(c);
  79                 return False;
  80         }
  81
  82         return True;
  83 }
  84
  85
  86
  87 static void close_connection(struct cli_state *c)
  88 {
  89         if (!cli_tdis(c)) {
  90                 printf("tdis failed (%s)\n", cli_errstr(c));
  91         }
  92
  93         cli_shutdown(c);
  94 }
  95
  96
  97 static BOOL wait_lock(struct cli_state *c, int fnum, uint32 offset, uint32 len)
  98 {
  99         while (!cli_lock(c, fnum, offset, len, -1)) {
 100                 int eclass, num;
 101                 cli_error(c, &eclass, &num);
 102                 if (eclass != ERRDOS || num != ERRlock) {
 103                         printf("lock failed (%s)\n",
 104                                cli_errstr(c));
 105                         return False;
 106                 }
 107         }
 108         return True;
 109 }
 110
 111
 112 static BOOL rw_torture(struct cli_state *c, int numops)
 113 {
 114         char *lockfname = "\\torture.lck";
 115         fstring fname;
 116         int fnum;
 117         int fnum2;
 118         int pid2, pid = getpid();
 119         int i;
 120
 121         fnum2 = cli_open(c, lockfname, O_RDWR | O_CREAT | O_EXCL,
 122                          DENY_NONE);
 123         if (fnum2 == -1)
 124                 fnum2 = cli_open(c, lockfname, O_RDWR, DENY_NONE);
 125         if (fnum2 == -1) {
 126                 printf("open of %s failed (%s)\n", lockfname, cli_errstr(c));
 127                 return False;
 128         }
 129
 130
 131         for (i=0;i<numops;i++) {
 132                 unsigned n = (unsigned)random()%10;
 133                 if (i % 10 == 0) {
 134                         printf("%d\r", i); fflush(stdout);
 135                 }
 136                 sprintf(fname,"\\torture.%u", n);
 137
 138                 if (!wait_lock(c, fnum2, n*sizeof(int), sizeof(int))) {
 139                         return False;
 140                 }
 141
 142                 fnum = cli_open(c, fname, O_RDWR | O_CREAT | O_TRUNC, DENY_ALL);
 143                 if (fnum == -1) {
 144                         printf("open failed (%s)\n", cli_errstr(c));
 145                         break;
 146                 }
 147
 148                 if (cli_write(c, fnum, (char *)&pid, 0, sizeof(pid)) != sizeof(pid)) {
 149                         printf("write failed (%s)\n", cli_errstr(c));
 150                 }
 151
 152                 pid2 = 0;
 153
 154                 if (cli_read(c, fnum, (char *)&pid2, 0, sizeof(pid)) != sizeof(pid)) {
 155                         printf("read failed (%s)\n", cli_errstr(c));
 156                 }
 157
 158                 if (pid2 != pid) {
 159                         printf("data corruption!\n");
 160                 }
 161
 162                 if (!cli_close(c, fnum)) {
 163                         printf("close failed (%s)\n", cli_errstr(c));
 164                 }
 165
 166                 if (!cli_unlink(c, fname)) {
 167                         printf("unlink failed (%s)\n", cli_errstr(c));
 168                 }
 169
 170                 if (!cli_unlock(c, fnum2, n*sizeof(int), sizeof(int), -1)) {
 171                         printf("unlock failed (%s)\n", cli_errstr(c));
 172                 }
 173         }
 174
 175         printf("%d\n", i);
 176
 177         return True;
 178 }
 179
 180 static void usage(void)
 181 {
 182         printf("Usage: smbtorture \\\\server\\share <options>\n");
 183
 184         printf("\t-U user%%pass\n");
 185         printf("\t-N numprocs\n");
 186         printf("\t-n my_netbios_name\n");
 187         printf("\t-W workgroup\n");
 188         printf("\t-o num_operations\n");
 189         printf("\t-O socket_options\n");
 190         printf("\t-m maximum protocol\n");
 191         printf("\n");
 192
 193         exit(1);
 194 }
 195
 196
 197
 198 static void run_torture(int numops)
 199 {
 200         static struct cli_state cli;
 201
 202         if (open_connection(&cli)) {
 203                 cli_sockopt(&cli, sockops);
 204
 205                 printf("pid %d OK\n", getpid());
 206
 207                 rw_torture(&cli, numops);
 208
 209                 close_connection(&cli);
 210         }
 211 }
 212
 213 /*
 214   This test checks for two things:
 215
 216   1) correct support for retaining locks over a close (ie. the server
 217      must not use posix semantics)
 218   2) support for lock timeouts
 219  */
 220 static void run_locktest1(void)
 221 {
 222         static struct cli_state cli1, cli2;
 223         char *fname = "\\locktest.lck";
 224         int fnum1, fnum2, fnum3;
 225         time_t t1, t2;
 226
 227         if (!open_connection(&cli1) || !open_connection(&cli2)) {
 228                 return;
 229         }
 230         cli_sockopt(&cli1, sockops);
 231         cli_sockopt(&cli2, sockops);
 232
 233         printf("starting locktest1\n");
 234
 235         cli_unlink(&cli1, fname);
 236
 237         fnum1 = cli_open(&cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
 238         if (fnum1 == -1) {
 239                 printf("open of %s failed (%s)\n", fname, cli_errstr(&cli1));
 240                 return;
 241         }
 242         fnum2 = cli_open(&cli1, fname, O_RDWR, DENY_NONE);
 243         if (fnum2 == -1) {
 244                 printf("open2 of %s failed (%s)\n", fname, cli_errstr(&cli1));
 245                 return;
 246         }
 247         fnum3 = cli_open(&cli2, fname, O_RDWR, DENY_NONE);
 248         if (fnum3 == -1) {
 249                 printf("open3 of %s failed (%s)\n", fname, cli_errstr(&cli2));
 250                 return;
 251         }
 252
 253         if (!cli_lock(&cli1, fnum1, 0, 4, 0)) {
 254                 printf("lock1 failed (%s)\n", cli_errstr(&cli1));
 255                 return;
 256         }
 257
 258
 259         if (cli_lock(&cli2, fnum3, 0, 4, 0)) {
 260                 printf("lock2 succeeded! This is a locking bug\n");
 261                 return;
 262         } else {
 263                 int eclass, num;
 264                 cli_error(&cli2, &eclass, &num);
 265                 if (eclass != ERRDOS || num != ERRlock) {
 266                         printf("error should have been ERRDOS/ERRlock (%s)\n",
 267                                cli_errstr(&cli2));
 268                         return;
 269                 }
 270         }
 271
 272
 273         printf("Testing lock timeouts\n");
 274         t1 = time(NULL);
 275         if (cli_lock(&cli2, fnum3, 0, 4, 10*1000)) {
 276                 printf("lock3 succeeded! This is a locking bug\n");
 277                 return;
 278         } else {
 279                 int eclass, num;
 280                 cli_error(&cli2, &eclass, &num);
 281                 if (eclass != ERRDOS || num != ERRlock) {
 282                         printf("error should have been ERRDOS/ERRlock (%s)\n",
 283                                cli_errstr(&cli2));
 284                         return;
 285                 }
 286         }
 287         t2 = time(NULL);
 288
 289         if (t2 - t1 < 5) {
 290                 printf("error: This server appears not to support timed lock requests\n");
 291         }
 292
 293         if (!cli_close(&cli1, fnum2)) {
 294                 printf("close1 failed (%s)\n", cli_errstr(&cli1));
 295                 return;
 296         }
 297
 298         if (cli_lock(&cli2, fnum3, 0, 4, 0)) {
 299                 printf("lock4 succeeded! This is a locking bug\n");
 300                 return;
 301         } else {
 302                 int eclass, num;
 303                 cli_error(&cli2, &eclass, &num);
 304                 if (eclass != ERRDOS || num != ERRlock) {
 305                         printf("error should have been ERRDOS/ERRlock (%s)\n",
 306                                cli_errstr(&cli2));
 307                         return;
 308                 }
 309         }
 310
 311         if (!cli_close(&cli1, fnum1)) {
 312                 printf("close2 failed (%s)\n", cli_errstr(&cli1));
 313                 return;
 314         }
 315
 316         if (!cli_close(&cli2, fnum3)) {
 317                 printf("close3 failed (%s)\n", cli_errstr(&cli2));
 318                 return;
 319         }
 320
 321         if (!cli_unlink(&cli1, fname)) {
 322                 printf("unlink failed (%s)\n", cli_errstr(&cli1));
 323                 return;
 324         }
 325
 326
 327         close_connection(&cli1);
 328         close_connection(&cli2);
 329
 330         printf("Passed locktest1\n");
 331 }
 332
 333
 334 /*
 335   This test checks that
 336
 337   1) the server supports multiple locking contexts on the one SMB
 338   connection, distinguished by PID.
 339
 340   2) the server correctly fails overlapping locks made by the same PID (this
 341      goes against POSIX behaviour, which is why it is tricky to implement)
 342
 343   3) the server denies unlock requests by an incorrect client PID
 344 */
 345 static void run_locktest2(void)
 346 {
 347         static struct cli_state cli;
 348         char *fname = "\\locktest.lck";
 349         int fnum1, fnum2, fnum3;
 350
 351         if (!open_connection(&cli)) {
 352                 return;
 353         }
 354
 355         cli_sockopt(&cli, sockops);
 356
 357         printf("starting locktest2\n");
 358
 359         cli_unlink(&cli, fname);
 360
 361         cli_setpid(&cli, 1);
 362
 363         fnum1 = cli_open(&cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
 364         if (fnum1 == -1) {
 365                 printf("open of %s failed (%s)\n", fname, cli_errstr(&cli));
 366                 return;
 367         }
 368
 369         fnum2 = cli_open(&cli, fname, O_RDWR, DENY_NONE);
 370         if (fnum2 == -1) {
 371                 printf("open2 of %s failed (%s)\n", fname, cli_errstr(&cli));
 372                 return;
 373         }
 374
 375         cli_setpid(&cli, 2);
 376
 377         fnum3 = cli_open(&cli, fname, O_RDWR, DENY_NONE);
 378         if (fnum3 == -1) {
 379                 printf("open3 of %s failed (%s)\n", fname, cli_errstr(&cli));
 380                 return;
 381         }
 382
 383         cli_setpid(&cli, 1);
 384
 385         if (!cli_lock(&cli, fnum1, 0, 4, 0)) {
 386                 printf("lock1 failed (%s)\n", cli_errstr(&cli));
 387                 return;
 388         }
 389
 390         if (cli_lock(&cli, fnum2, 0, 4, 0)) {
 391                 printf("lock2 succeeded! This is a locking bug\n");
 392         } else {
 393                 int eclass, num;
 394                 cli_error(&cli, &eclass, &num);
 395                 if (eclass != ERRDOS || num != ERRlock) {
 396                         printf("error should have been ERRDOS/ERRlock (%s)\n",
 397                                cli_errstr(&cli));
 398                         return;
 399                 }
 400         }
 401
 402         cli_setpid(&cli, 2);
 403
 404         if (cli_unlock(&cli, fnum1, 0, 4, 0)) {
 405                 printf("unlock1 succeeded! This is a locking bug\n");
 406         }
 407
 408         if (cli_lock(&cli, fnum3, 0, 4, 0)) {
 409                 printf("lock3 succeeded! This is a locking bug\n");
 410         } else {
 411                 int eclass, num;
 412                 cli_error(&cli, &eclass, &num);
 413                 if (eclass != ERRDOS || num != ERRlock) {
 414                         printf("error should have been ERRDOS/ERRlock (%s)\n",
 415                                cli_errstr(&cli));
 416                         return;
 417                 }
 418         }
 419
 420         cli_setpid(&cli, 1);
 421
 422         if (!cli_close(&cli, fnum1)) {
 423                 printf("close1 failed (%s)\n", cli_errstr(&cli));
 424                 return;
 425         }
 426
 427         if (!cli_close(&cli, fnum2)) {
 428                 printf("close2 failed (%s)\n", cli_errstr(&cli));
 429                 return;
 430         }
 431
 432         if (!cli_close(&cli, fnum3)) {
 433                 printf("close3 failed (%s)\n", cli_errstr(&cli));
 434                 return;
 435         }
 436
 437         close_connection(&cli);
 438
 439         printf("locktest2 finished\n");
 440 }
 441
 442
 443 /*
 444   This test checks that
 445
 446   1) the server supports the full offset range in lock requests
 447 */
 448 static void run_locktest3(int numops)
 449 {
 450         static struct cli_state cli1, cli2;
 451         char *fname = "\\locktest.lck";
 452         int fnum1, fnum2, i;
 453         uint32 offset;
 454
 455 #define NEXT_OFFSET offset += (~(uint32)0) / numops
 456
 457         if (!open_connection(&cli1) || !open_connection(&cli2)) {
 458                 return;
 459         }
 460         cli_sockopt(&cli1, sockops);
 461         cli_sockopt(&cli2, sockops);
 462
 463         printf("starting locktest3\n");
 464
 465         cli_unlink(&cli1, fname);
 466
 467         fnum1 = cli_open(&cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
 468         if (fnum1 == -1) {
 469                 printf("open of %s failed (%s)\n", fname, cli_errstr(&cli1));
 470                 return;
 471         }
 472         fnum2 = cli_open(&cli2, fname, O_RDWR, DENY_NONE);
 473         if (fnum2 == -1) {
 474                 printf("open2 of %s failed (%s)\n", fname, cli_errstr(&cli2));
 475                 return;
 476         }
 477
 478         for (offset=i=0;i<numops;i++) {
 479                 NEXT_OFFSET;
 480                 if (!cli_lock(&cli1, fnum1, offset-1, 1, 0)) {
 481                         printf("lock1 %d failed (%s)\n",
 482                                i,
 483                                cli_errstr(&cli1));
 484                         return;
 485                 }
 486
 487                 if (!cli_lock(&cli2, fnum2, offset-2, 1, 0)) {
 488                         printf("lock2 %d failed (%s)\n",
 489                                i,
 490                                cli_errstr(&cli1));
 491                         return;
 492                 }
 493         }
 494
 495         for (offset=i=0;i<numops;i++) {
 496                 NEXT_OFFSET;
 497
 498                 if (cli_lock(&cli1, fnum1, offset-2, 1, 0)) {
 499                         printf("error: lock1 %d succeeded!\n", i);
 500                         return;
 501                 }
 502
 503                 if (cli_lock(&cli2, fnum2, offset-1, 1, 0)) {
 504                         printf("error: lock2 %d succeeded!\n", i);
 505                         return;
 506                 }
 507
 508                 if (cli_lock(&cli1, fnum1, offset-1, 1, 0)) {
 509                         printf("error: lock3 %d succeeded!\n", i);
 510                         return;
 511                 }
 512
 513                 if (cli_lock(&cli2, fnum2, offset-2, 1, 0)) {
 514                         printf("error: lock4 %d succeeded!\n", i);
 515                         return;
 516                 }
 517         }
 518
 519         for (offset=i=0;i<numops;i++) {
 520                 NEXT_OFFSET;
 521
 522                 if (!cli_unlock(&cli1, fnum1, offset-1, 1, 0)) {
 523                         printf("unlock1 %d failed (%s)\n",
 524                                i,
 525                                cli_errstr(&cli1));
 526                         return;
 527                 }
 528
 529                 if (!cli_unlock(&cli2, fnum2, offset-2, 1, 0)) {
 530                         printf("unlock2 %d failed (%s)\n",
 531                                i,
 532                                cli_errstr(&cli1));
 533                         return;
 534                 }
 535         }
 536
 537         if (!cli_close(&cli1, fnum1)) {
 538                 printf("close1 failed (%s)\n", cli_errstr(&cli1));
 539         }
 540
 541         if (!cli_close(&cli2, fnum2)) {
 542                 printf("close2 failed (%s)\n", cli_errstr(&cli2));
 543         }
 544
 545         if (!cli_unlink(&cli1, fname)) {
 546                 printf("unlink failed (%s)\n", cli_errstr(&cli1));
 547                 return;
 548         }
 549
 550         close_connection(&cli1);
 551         close_connection(&cli2);
 552
 553         printf("finished locktest3\n");
 554 }
 555
 556
 557 /*
 558   This test checks that
 559
 560   1) the server does not allow an unlink on a file that is open
 561 */
 562 static void run_unlinktest(void)
 563 {
 564         static struct cli_state cli;
 565         char *fname = "\\unlink.tst";
 566         int fnum;
 567
 568         if (!open_connection(&cli)) {
 569                 return;
 570         }
 571
 572         cli_sockopt(&cli, sockops);
 573
 574         printf("starting unlink test\n");
 575
 576         cli_unlink(&cli, fname);
 577
 578         cli_setpid(&cli, 1);
 579
 580         fnum = cli_open(&cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
 581         if (fnum == -1) {
 582                 printf("open of %s failed (%s)\n", fname, cli_errstr(&cli));
 583                 return;
 584         }
 585
 586         if (cli_unlink(&cli, fname)) {
 587                 printf("error: server allowed unlink on an open file\n");
 588         }
 589
 590         close_connection(&cli);
 591
 592         printf("unlink test finished\n");
 593 }
 594
 595
 596
 597 static void browse_callback(char *sname, uint32 stype, char *comment)
 598 {
 599         printf("\t%20.20s %08x %s\n", sname, stype, comment);
 600 }
 601
 602
 603 /*
 604   This test checks the browse list code
 605
 606 */
 607 static void run_browsetest(void)
 608 {
 609         static struct cli_state cli;
 610
 611         printf("staring browse test\n");
 612
 613         if (!open_connection(&cli)) {
 614                 return;
 615         }
 616
 617         printf("domain list:\n");
 618         cli_NetServerEnum(&cli, workgroup,
 619                           SV_TYPE_DOMAIN_ENUM,
 620                           browse_callback);
 621
 622         printf("machine list:\n");
 623         cli_NetServerEnum(&cli, workgroup,
 624                           SV_TYPE_ALL,
 625                           browse_callback);
 626
 627         close_connection(&cli);
 628
 629         printf("browse test finished\n");
 630 }
 631
 632
 633 /*
 634   This checks how the getatr calls works
 635 */
 636 static void run_attrtest(void)
 637 {
 638         static struct cli_state cli;
 639         int fnum;
 640         struct stat st;
 641         char *fname = "\\attrib.tst";
 642
 643         printf("staring attrib test\n");
 644
 645         if (!open_connection(&cli)) {
 646                 return;
 647         }
 648
 649         cli_unlink(&cli, fname);
 650         fnum = cli_open(&cli, fname,
 651                         O_RDWR | O_CREAT | O_TRUNC, DENY_NONE);
 652         cli_close(&cli, fnum);
 653         if (!cli_stat(&cli, fname, &st)) {
 654                 printf("getatr failed (%s)\n", cli_errstr(&cli));
 655         }
 656
 657         if (abs(st.st_mtime - time(NULL)) > 2) {
 658                 printf("ERROR: SMBgetatr bug. time is %s",
 659                        ctime(&st.st_mtime));
 660         }
 661
 662         close_connection(&cli);
 663
 664         printf("attrib test finished\n");
 665 }
 666
 667
 668 static void create_procs(int nprocs, int numops)
 669 {
 670         int i, status;
 671
 672         for (i=0;i<nprocs;i++) {
 673                 if (fork() == 0) {
 674                         int mypid = getpid();
 675                         srandom(mypid ^ time(NULL));
 676                         run_torture(numops);
 677                         _exit(0);
 678                 }
 679         }
 680
 681         for (i=0;i<nprocs;i++)
 682                 waitpid(0, &status, 0);
 683 }
 684
 685
 686
 687 /****************************************************************************
 688   main program
 689 ****************************************************************************/
 690  int main(int argc,char *argv[])
 691 {
 692         int nprocs=1, numops=100;
 693         int opt;
 694         char *p;
 695         int gotpass = 0;
 696         extern char *optarg;
 697         extern int optind;
 698         extern FILE *dbf;
 699
 700         dbf = stdout;
 701
 702         charset_initialise();
 703
 704         if (argc < 2) {
 705                 usage();
 706         }
 707
 708         if (strncmp(argv[1], "\\\\", 2)) {
 709                 usage();
 710         }
 711
 712         fstrcpy(host, &argv[1][2]);
 713         p = strchr(&host[2],'\\');
 714         if (!p) {
 715                 usage();
 716         }
 717         *p = 0;
 718         fstrcpy(share, p+1);
 719
 720         get_myname(myname,NULL);
 721
 722         if (*username == 0 && getenv("LOGNAME")) {
 723           strcpy(username,getenv("LOGNAME"));
 724         }
 725
 726         argc--;
 727         argv++;
 728
 729
 730         while ((opt = getopt(argc, argv, "hW:U:n:N:O:o:m:")) != EOF) {
 731                 switch (opt) {
 732                 case 'W':
 733                         fstrcpy(workgroup,optarg);
 734                         break;
 735                 case 'm':
 736                         max_protocol = interpret_protocol(optarg, max_protocol);
 737                         break;
 738                 case 'N':
 739                         nprocs = atoi(optarg);
 740                         break;
 741                 case 'o':
 742                         numops = atoi(optarg);
 743                         break;
 744                 case 'O':
 745                         sockops = optarg;
 746                         break;
 747                 case 'n':
 748                         fstrcpy(myname, optarg);
 749                         break;
 750                 case 'U':
 751                         strcpy(username,optarg);
 752                         p = strchr(username,'%');
 753                         if (p) {
 754                                 *p = 0;
 755                                 strcpy(password, p+1);
 756                                 gotpass = 1;
 757                         }
 758                         break;
 759                 default:
 760                         printf("Unknown option %c (%d)\n", (char)opt, opt);
 761                         usage();
 762                 }
 763         }
 764
 765
 766         while (!gotpass) {
 767                 p = getpass("Password:");
 768                 if (p) {
 769                         strcpy(password, p);
 770                         gotpass = 1;
 771                 }
 772         }
 773
 774         printf("host=%s share=%s user=%s myname=%s\n",
 775                host, share, username, myname);
 776
 777         start_timer();
 778         create_procs(nprocs, numops);
 779         printf("rw_torture: %g secs\n", end_timer());
 780
 781         run_locktest1();
 782         run_locktest2();
 783         run_locktest3(numops);
 784         run_unlinktest();
 785         run_browsetest();
 786         run_attrtest();
 787
 788         return(0);
 789 }
 790
 791