r19392: Use torture_setting_* rather than lp_parm_* where possible.
[sfrench/samba-autobuild/.git] / source4 / torture / basic / misc.c
1 /* 
2    Unix SMB/CIFS implementation.
3    SMB torture tester
4    Copyright (C) Andrew Tridgell 1997-2003
5    Copyright (C) Jelmer Vernooij 2006
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 #include "includes.h"
23 #include "libcli/raw/libcliraw.h"
24 #include "system/time.h"
25 #include "system/wait.h"
26 #include "system/filesys.h"
27 #include "libcli/raw/ioctl.h"
28 #include "libcli/libcli.h"
29 #include "lib/events/events.h"
30 #include "libcli/resolve/resolve.h"
31 #include "auth/credentials/credentials.h"
32 #include "librpc/gen_ndr/ndr_nbt.h"
33 #include "torture/torture.h"
34 #include "torture/util.h"
35 #include "libcli/smb_composite/smb_composite.h"
36 #include "libcli/composite/composite.h"
37
38 extern struct cli_credentials *cmdline_credentials;
39 static void benchrw_callback(struct smbcli_request *req);
40 enum benchrw_stage {
41         START,
42         OPEN_CONNECTION,
43         CLEANUP_TESTDIR,
44         MK_TESTDIR,
45         OPEN_FILE,
46         INITIAL_WRITE,
47         READ_WRITE_DATA,
48         MAX_OPS_REACHED,
49         ERROR,
50         CLOSE_FILE,
51         CLEANUP,
52         FINISHED
53 };
54
55 struct benchrw_state{
56                 struct torture_context *tctx;
57                 char *dname;
58                 char *fname;
59                 uint16_t fnum;
60                 int nr;
61                 struct smbcli_tree      *cli;           
62                 uint8_t *buffer;
63                 int writecnt;
64                 int readcnt;
65                 int completed;
66                 TALLOC_CTX *mem_ctx;
67                 void *req_params;
68                 enum benchrw_stage mode;
69                 struct params{
70                         struct unclist{
71                                 const char *host;
72                                 const char *share;
73                         } **unc;
74                         const char *workgroup;
75                         int retry;
76                         unsigned int writeblocks;
77                         unsigned int blocksize;
78                         unsigned int writeratio;
79                 } *lp_params;
80         };
81         
82 static BOOL wait_lock(struct smbcli_state *c, int fnum, uint32_t offset, uint32_t len)
83 {
84         while (NT_STATUS_IS_ERR(smbcli_lock(c->tree, fnum, offset, len, -1, WRITE_LOCK))) {
85                 if (!check_error(__location__, c, ERRDOS, ERRlock, NT_STATUS_LOCK_NOT_GRANTED)) return False;
86         }
87         return True;
88 }
89
90
91 static BOOL rw_torture(struct torture_context *tctx, struct smbcli_state *c)
92 {
93         const char *lockfname = "\\torture.lck";
94         char *fname;
95         int fnum;
96         int fnum2;
97         pid_t pid2, pid = getpid();
98         int i, j;
99         uint8_t buf[1024];
100         BOOL correct = True;
101
102         fnum2 = smbcli_open(c->tree, lockfname, O_RDWR | O_CREAT | O_EXCL, 
103                          DENY_NONE);
104         if (fnum2 == -1)
105                 fnum2 = smbcli_open(c->tree, lockfname, O_RDWR, DENY_NONE);
106         if (fnum2 == -1) {
107                 torture_comment(tctx, "open of %s failed (%s)\n", lockfname, smbcli_errstr(c->tree));
108                 return False;
109         }
110
111
112         for (i=0;i<torture_numops;i++) {
113                 uint_t n = (uint_t)random()%10;
114                 if (i % 10 == 0) {
115                         torture_comment(tctx, "%d\r", i); fflush(stdout);
116                 }
117                 asprintf(&fname, "\\torture.%u", n);
118
119                 if (!wait_lock(c, fnum2, n*sizeof(int), sizeof(int))) {
120                         return False;
121                 }
122
123                 fnum = smbcli_open(c->tree, fname, O_RDWR | O_CREAT | O_TRUNC, DENY_ALL);
124                 if (fnum == -1) {
125                         torture_comment(tctx, "open failed (%s)\n", smbcli_errstr(c->tree));
126                         correct = False;
127                         break;
128                 }
129
130                 if (smbcli_write(c->tree, fnum, 0, &pid, 0, sizeof(pid)) != sizeof(pid)) {
131                         torture_comment(tctx, "write failed (%s)\n", smbcli_errstr(c->tree));
132                         correct = False;
133                 }
134
135                 for (j=0;j<50;j++) {
136                         if (smbcli_write(c->tree, fnum, 0, buf, 
137                                       sizeof(pid)+(j*sizeof(buf)), 
138                                       sizeof(buf)) != sizeof(buf)) {
139                                 torture_comment(tctx, "write failed (%s)\n", smbcli_errstr(c->tree));
140                                 correct = False;
141                         }
142                 }
143
144                 pid2 = 0;
145
146                 if (smbcli_read(c->tree, fnum, &pid2, 0, sizeof(pid)) != sizeof(pid)) {
147                         torture_comment(tctx, "read failed (%s)\n", smbcli_errstr(c->tree));
148                         correct = False;
149                 }
150
151                 if (pid2 != pid) {
152                         torture_comment(tctx, "data corruption!\n");
153                         correct = False;
154                 }
155
156                 if (NT_STATUS_IS_ERR(smbcli_close(c->tree, fnum))) {
157                         torture_comment(tctx, "close failed (%s)\n", smbcli_errstr(c->tree));
158                         correct = False;
159                 }
160
161                 if (NT_STATUS_IS_ERR(smbcli_unlink(c->tree, fname))) {
162                         torture_comment(tctx, "unlink failed (%s)\n", smbcli_errstr(c->tree));
163                         correct = False;
164                 }
165
166                 if (NT_STATUS_IS_ERR(smbcli_unlock(c->tree, fnum2, n*sizeof(int), sizeof(int)))) {
167                         torture_comment(tctx, "unlock failed (%s)\n", smbcli_errstr(c->tree));
168                         correct = False;
169                 }
170                 free(fname);
171         }
172
173         smbcli_close(c->tree, fnum2);
174         smbcli_unlink(c->tree, lockfname);
175
176         torture_comment(tctx, "%d\n", i);
177
178         return correct;
179 }
180
181 BOOL run_torture(struct torture_context *tctx, struct smbcli_state *cli, int dummy)
182 {
183         return rw_torture(tctx, cli);
184 }
185
186
187 /*
188   see how many RPC pipes we can open at once
189 */
190 BOOL run_pipe_number(struct torture_context *tctx, 
191                                          struct smbcli_state *cli1)
192 {
193         const char *pipe_name = "\\WKSSVC";
194         int fnum;
195         int num_pipes = 0;
196
197         while(1) {
198                 fnum = smbcli_nt_create_full(cli1->tree, pipe_name, 0, SEC_FILE_READ_DATA, FILE_ATTRIBUTE_NORMAL,
199                                    NTCREATEX_SHARE_ACCESS_READ|NTCREATEX_SHARE_ACCESS_WRITE, NTCREATEX_DISP_OPEN_IF, 0, 0);
200
201                 if (fnum == -1) {
202                         torture_comment(tctx, "Open of pipe %s failed with error (%s)\n", pipe_name, smbcli_errstr(cli1->tree));
203                         break;
204                 }
205                 num_pipes++;
206                 torture_comment(tctx, "%d\r", num_pipes);
207                 fflush(stdout);
208         }
209
210         torture_comment(tctx, "pipe_number test - we can open %d %s pipes.\n", num_pipes, pipe_name );
211         return True;
212 }
213
214
215
216
217 /*
218   open N connections to the server and just hold them open
219   used for testing performance when there are N idle users
220   already connected
221  */
222 BOOL torture_holdcon(struct torture_context *tctx)
223 {
224         int i;
225         struct smbcli_state **cli;
226         int num_dead = 0;
227
228         torture_comment(tctx, "Opening %d connections\n", torture_numops);
229         
230         cli = malloc_array_p(struct smbcli_state *, torture_numops);
231
232         for (i=0;i<torture_numops;i++) {
233                 if (!torture_open_connection(&cli[i], i)) {
234                         return False;
235                 }
236                 torture_comment(tctx, "opened %d connections\r", i);
237                 fflush(stdout);
238         }
239
240         torture_comment(tctx, "\nStarting pings\n");
241
242         while (1) {
243                 for (i=0;i<torture_numops;i++) {
244                         NTSTATUS status;
245                         if (cli[i]) {
246                                 status = smbcli_chkpath(cli[i]->tree, "\\");
247                                 if (!NT_STATUS_IS_OK(status)) {
248                                         torture_comment(tctx, "Connection %d is dead\n", i);
249                                         cli[i] = NULL;
250                                         num_dead++;
251                                 }
252                                 usleep(100);
253                         }
254                 }
255
256                 if (num_dead == torture_numops) {
257                         torture_comment(tctx, "All connections dead - finishing\n");
258                         break;
259                 }
260
261                 torture_comment(tctx, ".");
262                 fflush(stdout);
263         }
264
265         return True;
266 }
267
268 /*
269 test how many open files this server supports on the one socket
270 */
271 BOOL run_maxfidtest(struct torture_context *tctx, struct smbcli_state *cli, int dummy)
272 {
273 #define MAXFID_TEMPLATE "\\maxfid\\fid%d\\maxfid.%d.%d"
274         char *fname;
275         int fnums[0x11000], i;
276         int retries=4, maxfid;
277         BOOL correct = True;
278
279         if (retries <= 0) {
280                 torture_comment(tctx, "failed to connect\n");
281                 return False;
282         }
283
284         if (smbcli_deltree(cli->tree, "\\maxfid") == -1) {
285                 torture_comment(tctx, "Failed to deltree \\maxfid - %s\n",
286                        smbcli_errstr(cli->tree));
287                 return False;
288         }
289         if (NT_STATUS_IS_ERR(smbcli_mkdir(cli->tree, "\\maxfid"))) {
290                 torture_comment(tctx, "Failed to mkdir \\maxfid, error=%s\n", 
291                        smbcli_errstr(cli->tree));
292                 return False;
293         }
294
295         torture_comment(tctx, "Testing maximum number of open files\n");
296
297         for (i=0; i<0x11000; i++) {
298                 if (i % 1000 == 0) {
299                         asprintf(&fname, "\\maxfid\\fid%d", i/1000);
300                         if (NT_STATUS_IS_ERR(smbcli_mkdir(cli->tree, fname))) {
301                                 torture_comment(tctx, "Failed to mkdir %s, error=%s\n", 
302                                        fname, smbcli_errstr(cli->tree));
303                                 return False;
304                         }
305                         free(fname);
306                 }
307                 asprintf(&fname, MAXFID_TEMPLATE, i/1000, i,(int)getpid());
308                 if ((fnums[i] = smbcli_open(cli->tree, fname, 
309                                         O_RDWR|O_CREAT|O_TRUNC, DENY_NONE)) ==
310                     -1) {
311                         torture_comment(tctx, "open of %s failed (%s)\n", 
312                                fname, smbcli_errstr(cli->tree));
313                         torture_comment(tctx, "maximum fnum is %d\n", i);
314                         break;
315                 }
316                 free(fname);
317                 torture_comment(tctx, "%6d\r", i);
318         }
319         torture_comment(tctx, "%6d\n", i);
320         i--;
321
322         maxfid = i;
323
324         torture_comment(tctx, "cleaning up\n");
325         for (i=0;i<maxfid/2;i++) {
326                 asprintf(&fname, MAXFID_TEMPLATE, i/1000, i,(int)getpid());
327                 if (NT_STATUS_IS_ERR(smbcli_close(cli->tree, fnums[i]))) {
328                         torture_comment(tctx, "Close of fnum %d failed - %s\n", fnums[i], smbcli_errstr(cli->tree));
329                 }
330                 if (NT_STATUS_IS_ERR(smbcli_unlink(cli->tree, fname))) {
331                         torture_comment(tctx, "unlink of %s failed (%s)\n", 
332                                fname, smbcli_errstr(cli->tree));
333                         correct = False;
334                 }
335                 free(fname);
336
337                 asprintf(&fname, MAXFID_TEMPLATE, (maxfid-i)/1000, maxfid-i,(int)getpid());
338                 if (NT_STATUS_IS_ERR(smbcli_close(cli->tree, fnums[maxfid-i]))) {
339                         torture_comment(tctx, "Close of fnum %d failed - %s\n", fnums[maxfid-i], smbcli_errstr(cli->tree));
340                 }
341                 if (NT_STATUS_IS_ERR(smbcli_unlink(cli->tree, fname))) {
342                         torture_comment(tctx, "unlink of %s failed (%s)\n", 
343                                fname, smbcli_errstr(cli->tree));
344                         correct = False;
345                 }
346                 free(fname);
347
348                 torture_comment(tctx, "%6d %6d\r", i, maxfid-i);
349         }
350         torture_comment(tctx, "%6d\n", 0);
351
352         if (smbcli_deltree(cli->tree, "\\maxfid") == -1) {
353                 torture_comment(tctx, "Failed to deltree \\maxfid - %s\n",
354                        smbcli_errstr(cli->tree));
355                 return False;
356         }
357
358         torture_comment(tctx, "maxfid test finished\n");
359         if (!torture_close_connection(cli)) {
360                 correct = False;
361         }
362         return correct;
363 #undef MAXFID_TEMPLATE
364 }
365
366
367
368 /*
369   sees what IOCTLs are supported
370  */
371 BOOL torture_ioctl_test(struct torture_context *tctx, 
372                                                 struct smbcli_state *cli)
373 {
374         uint16_t device, function;
375         int fnum;
376         const char *fname = "\\ioctl.dat";
377         NTSTATUS status;
378         union smb_ioctl parms;
379         TALLOC_CTX *mem_ctx;
380
381         mem_ctx = talloc_named_const(tctx, 0, "ioctl_test");
382
383         smbcli_unlink(cli->tree, fname);
384
385         fnum = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
386         if (fnum == -1) {
387                 torture_comment(tctx, "open of %s failed (%s)\n", fname, smbcli_errstr(cli->tree));
388                 return False;
389         }
390
391         parms.ioctl.level = RAW_IOCTL_IOCTL;
392         parms.ioctl.in.file.fnum = fnum;
393         parms.ioctl.in.request = IOCTL_QUERY_JOB_INFO;
394         status = smb_raw_ioctl(cli->tree, mem_ctx, &parms);
395         torture_comment(tctx, "ioctl job info: %s\n", smbcli_errstr(cli->tree));
396
397         for (device=0;device<0x100;device++) {
398                 torture_comment(tctx, "testing device=0x%x\n", device);
399                 for (function=0;function<0x100;function++) {
400                         parms.ioctl.in.request = (device << 16) | function;
401                         status = smb_raw_ioctl(cli->tree, mem_ctx, &parms);
402
403                         if (NT_STATUS_IS_OK(status)) {
404                                 torture_comment(tctx, "ioctl device=0x%x function=0x%x OK : %d bytes\n", 
405                                         device, function, (int)parms.ioctl.out.blob.length);
406                         }
407                 }
408         }
409
410         return True;
411 }
412
413 /* 
414         init params using lp_parm_xxx 
415         return number of unclist entries
416 */
417 static int init_benchrw_params(struct torture_context *tctx, struct params *lpar)
418 {
419         char **unc_list = NULL;
420         int num_unc_names = 0, conn_index=0, empty_lines=0;
421         const char *p;
422         lpar->retry = torture_setting_int(tctx, "retry",3);
423         lpar->blocksize = torture_setting_int(tctx, "blocksize",65535);
424         lpar->writeblocks = torture_setting_int(tctx, "writeblocks",15);
425         lpar->writeratio = torture_setting_int(tctx, "writeratio",5);
426         lpar->workgroup = lp_workgroup();
427         
428         p = torture_setting_string(tctx, "unclist", NULL);
429         if (p) {
430                 char *h, *s;
431                 unc_list = file_lines_load(p, &num_unc_names, NULL);
432                 if (!unc_list || num_unc_names <= 0) {
433                         torture_comment(tctx, "Failed to load unc names list from '%s'\n", p);
434                         exit(1);
435                 }
436                 
437                 lpar->unc = talloc_array(tctx, struct unclist *, (num_unc_names-empty_lines));
438                 for(conn_index = 0; conn_index < num_unc_names; conn_index++) {
439                         /* ignore empty lines */
440                         if(strlen(unc_list[conn_index % num_unc_names])==0){
441                                 empty_lines++;
442                                 continue;
443                         }
444                         if (!smbcli_parse_unc(unc_list[conn_index % num_unc_names],
445                                               NULL, &h, &s)) {
446                                 torture_comment(tctx, "Failed to parse UNC name %s\n",
447                                unc_list[conn_index % num_unc_names]);
448                                 exit(1);
449                         }
450                 lpar->unc[conn_index-empty_lines] = talloc(tctx,struct unclist);
451                 lpar->unc[conn_index-empty_lines]->host = h;
452                 lpar->unc[conn_index-empty_lines]->share = s;   
453                 }
454                 return num_unc_names-empty_lines;
455         }else{
456                 lpar->unc = talloc_array(tctx, struct unclist *, 1);
457                 lpar->unc[0] = talloc(tctx,struct unclist);
458                 lpar->unc[0]->host  = torture_setting_string(tctx, "host", NULL);
459                 lpar->unc[0]->share = torture_setting_string(tctx, "share", NULL);
460                 return 1;
461         }
462 }
463
464 /*
465  Called when the reads & writes are finished. closes the file.
466 */
467 static NTSTATUS benchrw_close(struct torture_context *tctx,struct smbcli_request *req,
468                                 struct benchrw_state *state)
469 {
470         union smb_close close_parms;
471         
472         NT_STATUS_NOT_OK_RETURN(req->status);
473         
474         torture_comment(tctx, "Close file %d (%d)\n",state->nr,state->fnum);
475         close_parms.close.level = RAW_CLOSE_CLOSE;
476         close_parms.close.in.file.fnum = state->fnum ;
477         close_parms.close.in.write_time = 0;
478         state->mode=CLOSE_FILE;
479         
480         req = smb_raw_close_send(state->cli, &close_parms);
481         NT_STATUS_HAVE_NO_MEMORY(req);
482         /*register the callback function!*/
483         req->async.fn = benchrw_callback;
484         req->async.private = state;
485         
486         return NT_STATUS_OK;
487 }
488
489 /*
490  Called when the initial write is completed is done. write or read a file.
491 */
492 static NTSTATUS benchrw_readwrite(struct torture_context *tctx,struct smbcli_request *req,
493                                         struct benchrw_state *state)
494 {
495         union smb_read  rd;
496         union smb_write wr;
497         
498         NT_STATUS_NOT_OK_RETURN(req->status);
499         
500         state->completed++;
501         /*rotate between writes and reads*/
502         if( state->completed % state->lp_params->writeratio == 0){
503                 torture_comment(tctx, "Callback WRITE file:%d (%d/%d)\n",
504                                 state->nr,state->completed,torture_numops);
505                 wr.generic.level = RAW_WRITE_WRITEX  ;
506                 wr.writex.in.file.fnum  = state->fnum ;
507                 wr.writex.in.offset     = 0;
508                 wr.writex.in.wmode      = 0             ;
509                 wr.writex.in.remaining  = 0;
510                 wr.writex.in.count      = state->lp_params->blocksize;
511                 wr.writex.in.data       = state->buffer;
512                 state->readcnt=0;
513                 req = smb_raw_write_send(state->cli,&wr);
514         }else{
515                 torture_comment(tctx, "Callback READ file:%d (%d/%d) Offset:%d\n",
516                                 state->nr,state->completed,torture_numops,
517                                 (state->readcnt*state->lp_params->blocksize));
518                 rd.generic.level = RAW_READ_READ    ;
519                 rd.read.in.file.fnum    = state->fnum   ;
520                 rd.read.in.offset       = state->readcnt * 
521                                         state->lp_params->blocksize;
522                 rd.read.in.count        = state->lp_params->blocksize;
523                 rd.read.in.remaining    = 0     ;
524                 rd.read.out.data        = state->buffer;
525                 if(state->readcnt < state->lp_params->writeblocks){
526                         state->readcnt++;       
527                 }else{
528                         /*start reading from beginn of file*/
529                         state->readcnt=0;
530                 }
531                 req = smb_raw_read_send(state->cli,&rd);
532         }
533         NT_STATUS_HAVE_NO_MEMORY(req);
534         /*register the callback function!*/
535         req->async.fn = benchrw_callback;
536         req->async.private = state;
537         
538         return NT_STATUS_OK;
539 }
540
541 /*
542  Called when the open is done. writes to the file.
543 */
544 static NTSTATUS benchrw_open(struct torture_context *tctx,struct smbcli_request *req,
545                                 struct benchrw_state *state)
546 {
547         union smb_write wr;
548         if(state->mode == OPEN_FILE){
549                 NTSTATUS status;
550                 status = smb_raw_open_recv(req,state->mem_ctx,(
551                                         union smb_open*)state->req_params);
552                 NT_STATUS_NOT_OK_RETURN(status);
553         
554                 state->fnum = ((union smb_open*)state->req_params)
555                                                 ->openx.out.file.fnum;
556                 torture_comment(tctx, "File opened (%d)\n",state->fnum);
557                 state->mode=INITIAL_WRITE;
558         }
559                 
560         torture_comment(tctx, "Write initial test file:%d (%d/%d)\n",state->nr,
561                 (state->writecnt+1)*state->lp_params->blocksize,
562                 (state->lp_params->writeblocks*state->lp_params->blocksize));
563         wr.generic.level = RAW_WRITE_WRITEX  ;
564         wr.writex.in.file.fnum  = state->fnum ;
565         wr.writex.in.offset     = state->writecnt * 
566                                         state->lp_params->blocksize;
567         wr.writex.in.wmode      = 0             ;
568         wr.writex.in.remaining  = (state->lp_params->writeblocks *
569                                                 state->lp_params->blocksize)-
570                                                 ((state->writecnt+1)*state->
571                                                 lp_params->blocksize);
572         wr.writex.in.count      = state->lp_params->blocksize;
573         wr.writex.in.data       = state->buffer;
574         state->writecnt++;
575         if(state->writecnt == state->lp_params->writeblocks){
576                 state->mode=READ_WRITE_DATA;
577         }
578         req = smb_raw_write_send(state->cli,&wr);
579         NT_STATUS_HAVE_NO_MEMORY(req);
580         
581         /*register the callback function!*/
582         req->async.fn = benchrw_callback;
583         req->async.private = state;
584         return NT_STATUS_OK;
585
586
587 /*
588  Called when the mkdir is done. Opens a file.
589 */
590 static NTSTATUS benchrw_mkdir(struct torture_context *tctx,struct smbcli_request *req,
591                                 struct benchrw_state *state)
592 {
593         union smb_open *open_parms;     
594         uint8_t *writedata;     
595                 
596         NT_STATUS_NOT_OK_RETURN(req->status);
597         
598         /* open/create the files */
599         torture_comment(tctx, "Open File %d/%d\n",state->nr+1,torture_nprocs);
600         open_parms=talloc_zero(state->mem_ctx, union smb_open);
601         NT_STATUS_HAVE_NO_MEMORY(open_parms);
602         open_parms->openx.level = RAW_OPEN_OPENX;
603         open_parms->openx.in.flags = 0;
604         open_parms->openx.in.open_mode = OPENX_MODE_ACCESS_RDWR;
605         open_parms->openx.in.search_attrs = 
606                         FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN;
607         open_parms->openx.in.file_attrs = 0;
608         open_parms->openx.in.write_time = 0;
609         open_parms->openx.in.open_func = OPENX_OPEN_FUNC_CREATE;
610         open_parms->openx.in.size = 0;
611         open_parms->openx.in.timeout = 0;
612         open_parms->openx.in.fname = state->fname;
613                 
614         writedata = talloc_size(state->mem_ctx,state->lp_params->blocksize);
615         NT_STATUS_HAVE_NO_MEMORY(writedata);
616         generate_random_buffer(writedata,state->lp_params->blocksize);
617         state->buffer=writedata;
618         state->writecnt=1;
619         state->readcnt=0;
620         state->req_params=open_parms;           
621         state->mode=OPEN_FILE;  
622                         
623         req = smb_raw_open_send(state->cli,open_parms);
624         NT_STATUS_HAVE_NO_MEMORY(req);
625         
626         /*register the callback function!*/
627         req->async.fn = benchrw_callback;
628         req->async.private = state;
629                 
630         return NT_STATUS_OK;
631 }
632
633 /*
634  handler for completion of a sub-request of the bench-rw test
635 */
636 static void benchrw_callback(struct smbcli_request *req)
637 {
638         struct benchrw_state *state = req->async.private;
639         struct torture_context *tctx = state->tctx;
640         
641         /*dont send new requests when torture_numops is reached*/
642         if(state->completed >= torture_numops){
643                 state->completed=0;
644                 state->mode=MAX_OPS_REACHED;
645         }
646         
647         switch (state->mode) {
648         
649         case MK_TESTDIR:
650                 if (!NT_STATUS_IS_OK(benchrw_mkdir(tctx, req,state))) {                 
651                         torture_comment(tctx, "Failed to create the test directory - %s\n", 
652                                                         nt_errstr(req->status));
653                         state->mode=ERROR;
654                         return;
655                 }
656                 break;  
657         case OPEN_FILE:
658         case INITIAL_WRITE:
659                 if (!NT_STATUS_IS_OK(benchrw_open(tctx, req,state))){
660                         torture_comment(tctx, "Failed to open/write the file - %s\n", 
661                                                         nt_errstr(req->status));
662                         state->mode=ERROR;
663                         return;
664                 }
665                 break;
666         case READ_WRITE_DATA:
667                 if (!NT_STATUS_IS_OK(benchrw_readwrite(tctx,req,state))){
668                         torture_comment(tctx, "Failed to read/write the file - %s\n", 
669                                                         nt_errstr(req->status));
670                         state->mode=ERROR;
671                         return;
672                 }
673                 break;
674         case MAX_OPS_REACHED:
675                 if (!NT_STATUS_IS_OK(benchrw_close(tctx,req,state))){
676                         torture_comment(tctx, "Failed to read/write/close the file - %s\n", 
677                                                         nt_errstr(req->status));
678                         state->mode=ERROR;
679                         return;
680                 }
681                 break;
682         case CLOSE_FILE:
683                 torture_comment(tctx, "File %d closed\n",state->nr);
684                 if (!NT_STATUS_IS_OK(req->status)) {
685                         torture_comment(tctx, "Failed to close the file - %s\n",
686                                                         nt_errstr(req->status));
687                         state->mode=ERROR;
688                         return;
689                 }
690                 state->mode=CLEANUP;
691                 return; 
692         default:
693                 break;
694         }
695         
696 }
697
698 /* open connection async callback function*/
699 static void async_open_callback(struct composite_context *con)
700 {
701         struct benchrw_state *state = con->async.private_data;
702         struct torture_context *tctx = state->tctx;
703         int retry = state->lp_params->retry;
704                 
705         if (NT_STATUS_IS_OK(con->status)) {
706                 state->cli=((struct smb_composite_connect*)
707                                         state->req_params)->out.tree;
708                 state->mode=CLEANUP_TESTDIR;
709         }else{
710                 if(state->writecnt < retry){
711                         torture_comment(tctx, "Failed to open connection:%d, Retry (%d/%d)\n",
712                                         state->nr,state->writecnt,retry);
713                         state->writecnt++;
714                         state->mode=START;
715                         usleep(1000);   
716                 }else{
717                         torture_comment(tctx, "Failed to open connection (%d) - %s\n",
718                                         state->nr, nt_errstr(con->status));
719                         state->mode=ERROR;
720                 }
721                 return;
722         }       
723 }
724
725 /*
726  establishs a smbcli_tree from scratch (async)
727 */
728 static struct composite_context *torture_connect_async(
729                                 struct torture_context *tctx,
730                                 struct smb_composite_connect *smb,
731                                 TALLOC_CTX *mem_ctx,
732                                 struct event_context *ev,
733                                 const char *host,
734                                 const char *share,
735                                 const char *workgroup)
736 {
737         torture_comment(tctx, "Open Connection to %s/%s\n",host,share);
738         smb->in.dest_host=talloc_strdup(mem_ctx,host);
739         smb->in.service=talloc_strdup(mem_ctx,share);
740         smb->in.port=0;
741         smb->in.called_name = strupper_talloc(mem_ctx, host);
742         smb->in.service_type=NULL;
743         smb->in.credentials=cmdline_credentials;
744         smb->in.fallback_to_anonymous=False;
745         smb->in.workgroup=workgroup;
746         
747         return smb_composite_connect_send(smb,mem_ctx,ev);
748 }
749
750 BOOL run_benchrw(struct torture_context *tctx)
751 {
752         struct smb_composite_connect *smb_con;
753         const char *fname = "\\rwtest.dat";
754         struct smbcli_request *req;
755         struct benchrw_state **state;
756         int i , num_unc_names;
757         struct event_context    *ev     ;       
758         struct composite_context *req1;
759         struct params lpparams;
760         union smb_mkdir parms;
761         int finished = 0;
762         BOOL success=True;
763         
764         torture_comment(tctx, "Start BENCH-READWRITE num_ops=%d num_nprocs=%d\n",
765                 torture_numops,torture_nprocs);
766
767         /*init talloc context*/
768         ev = event_context_init(tctx);
769         state = talloc_array(tctx, struct benchrw_state *, torture_nprocs);
770
771         /* init params using lp_parm_xxx */
772         num_unc_names = init_benchrw_params(tctx,&lpparams);
773         
774         /* init private data structs*/
775         for(i = 0; i<torture_nprocs;i++){
776                 state[i]=talloc(tctx,struct benchrw_state);
777                 state[i]->tctx = tctx;
778                 state[i]->completed=0;
779                 state[i]->lp_params=&lpparams;
780                 state[i]->nr=i;
781                 state[i]->dname=talloc_asprintf(tctx,"benchrw%d",i);
782                 state[i]->fname=talloc_asprintf(tctx,"%s%s",
783                                                                 state[i]->dname,fname); 
784                 state[i]->mode=START;
785                 state[i]->writecnt=0;
786         }
787         
788         torture_comment(tctx, "Starting async requests\n");     
789         while(finished != torture_nprocs){
790                 finished=0;
791                 for(i = 0; i<torture_nprocs;i++){
792                         switch (state[i]->mode){
793                         /*open multiple connections with the same userid */
794                         case START:
795                                 smb_con = talloc(tctx,struct smb_composite_connect) ;
796                                 state[i]->req_params=smb_con; 
797                                 state[i]->mode=OPEN_CONNECTION;
798                                 req1 = torture_connect_async(tctx, smb_con,
799                                                                         tctx,ev,
800                                                                         lpparams.unc[i % num_unc_names]->host,
801                                                                         lpparams.unc[i % num_unc_names]->share,
802                                                                         lpparams.workgroup);
803                                 /* register callback fn + private data */
804                                 req1->async.fn = async_open_callback;
805                                 req1->async.private_data=state[i];
806                                 break;
807                         /*setup test dirs (sync)*/
808                         case CLEANUP_TESTDIR:
809                                 torture_comment(tctx, "Setup test dir %d\n",i);
810                                 smb_raw_exit(state[i]->cli->session);
811                                 if (smbcli_deltree(state[i]->cli, 
812                                                 state[i]->dname) == -1) {
813                                         torture_comment(tctx, "Unable to delete %s - %s\n", 
814                                                 state[i]->dname,
815                                                 smbcli_errstr(state[i]->cli));
816                                         state[i]->mode=ERROR;
817                                         break;
818                                 }
819                                 state[i]->mode=MK_TESTDIR;
820                                 parms.mkdir.level = RAW_MKDIR_MKDIR;
821                                 parms.mkdir.in.path = state[i]->dname;
822                                 req = smb_raw_mkdir_send(state[i]->cli,&parms);
823                                 /* register callback fn + private data */
824                                 req->async.fn = benchrw_callback;
825                                 req->async.private=state[i];
826                                 break;
827                         /* error occured , finish */
828                         case ERROR:
829                                 finished++;
830                                 success=False;
831                                 break;
832                         /* cleanup , close connection */
833                         case CLEANUP:
834                                 torture_comment(tctx, "Deleting test dir %s %d/%d\n",state[i]->dname,
835                                                 i+1,torture_nprocs);
836                                 smbcli_deltree(state[i]->cli,state[i]->dname);
837                                 if (NT_STATUS_IS_ERR(smb_tree_disconnect(
838                                                                                 state[i]->cli))) {
839                                         torture_comment(tctx, "ERROR: Tree disconnect failed");
840                                         state[i]->mode=ERROR;
841                                         break;
842                                 }
843                                 state[i]->mode=FINISHED;
844                         case FINISHED:
845                                 finished++;
846                                 break;
847                         default:
848                                 event_loop_once(ev);
849                         }
850                 }
851         }
852                                 
853         return success; 
854 }
855