06fbe667eab2a32cbc669a0af8ee41fb765129d8
[jelmer/samba4-debian.git] / source / torture / raw / write.c
1 /* 
2    Unix SMB/CIFS implementation.
3    test suite for various write operations
4
5    Copyright (C) Andrew Tridgell 2003
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
26 #define CHECK_STATUS(status, correct) do { \
27         if (!NT_STATUS_EQUAL(status, correct)) { \
28                 printf("(%s) Incorrect status %s - should be %s\n", \
29                        __location__, nt_errstr(status), nt_errstr(correct)); \
30                 ret = False; \
31                 goto done; \
32         }} while (0)
33
34 #define CHECK_VALUE(v, correct) do { \
35         if ((v) != (correct)) { \
36                 printf("(%s) Incorrect value %s=%d - should be %d\n", \
37                        __location__, #v, v, correct); \
38                 ret = False; \
39                 goto done; \
40         }} while (0)
41
42 #define CHECK_BUFFER(buf, seed, len) do { \
43         if (!check_buffer(buf, seed, len, __location__)) { \
44                 ret = False; \
45                 goto done; \
46         }} while (0)
47
48 #define CHECK_ALL_INFO(v, field) do { \
49         finfo.all_info.level = RAW_FILEINFO_ALL_INFO; \
50         finfo.all_info.in.fname = fname; \
51         status = smb_raw_pathinfo(cli->tree, mem_ctx, &finfo); \
52         CHECK_STATUS(status, NT_STATUS_OK); \
53         if ((v) != finfo.all_info.out.field) { \
54                 printf("(%s) wrong value for field %s  %.0f - %.0f\n", \
55                        __location__, #field, (double)v, (double)finfo.all_info.out.field); \
56                 dump_all_info(mem_ctx, &finfo); \
57                 ret = False; \
58         }} while (0)
59
60
61 #define BASEDIR "\\testwrite"
62
63
64 /*
65   setup a random buffer based on a seed
66 */
67 static void setup_buffer(uint8_t *buf, uint_t seed, int len)
68 {
69         int i;
70         srandom(seed);
71         for (i=0;i<len;i++) buf[i] = random();
72 }
73
74 /*
75   check a random buffer based on a seed
76 */
77 static BOOL check_buffer(uint8_t *buf, uint_t seed, int len, const char *location)
78 {
79         int i;
80         srandom(seed);
81         for (i=0;i<len;i++) {
82                 uint8_t v = random();
83                 if (buf[i] != v) {
84                         printf("Buffer incorrect at %s! ofs=%d buf=0x%x correct=0x%x\n", 
85                                location, i, buf[i], v);
86                         return False;
87                 }
88         }
89         return True;
90 }
91
92 /*
93   test write ops
94 */
95 static BOOL test_write(struct smbcli_state *cli, TALLOC_CTX *mem_ctx)
96 {
97         union smb_write io;
98         NTSTATUS status;
99         BOOL ret = True;
100         int fnum;
101         uint8_t *buf;
102         const int maxsize = 90000;
103         const char *fname = BASEDIR "\\test.txt";
104         uint_t seed = time(NULL);
105         union smb_fileinfo finfo;
106
107         buf = talloc_zero(mem_ctx, maxsize);
108
109         if (!torture_setup_dir(cli, BASEDIR)) {
110                 return False;
111         }
112
113         printf("Testing RAW_WRITE_WRITE\n");
114         io.generic.level = RAW_WRITE_WRITE;
115         
116         fnum = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
117         if (fnum == -1) {
118                 printf("Failed to create %s - %s\n", fname, smbcli_errstr(cli->tree));
119                 ret = False;
120                 goto done;
121         }
122
123         printf("Trying zero write\n");
124         io.write.in.fnum = fnum;
125         io.write.in.count = 0;
126         io.write.in.offset = 0;
127         io.write.in.remaining = 0;
128         io.write.in.data = buf;
129         status = smb_raw_write(cli->tree, &io);
130         CHECK_STATUS(status, NT_STATUS_OK);
131         CHECK_VALUE(io.write.out.nwritten, 0);
132
133         setup_buffer(buf, seed, maxsize);
134
135         printf("Trying small write\n");
136         io.write.in.count = 9;
137         io.write.in.offset = 4;
138         io.write.in.data = buf;
139         status = smb_raw_write(cli->tree, &io);
140         CHECK_STATUS(status, NT_STATUS_OK);
141         CHECK_VALUE(io.write.out.nwritten, io.write.in.count);
142
143         memset(buf, 0, maxsize);
144         if (smbcli_read(cli->tree, fnum, buf, 0, 13) != 13) {
145                 printf("read failed at %s\n", __location__);
146                 ret = False;
147                 goto done;
148         }
149         CHECK_BUFFER(buf+4, seed, 9);
150         CHECK_VALUE(IVAL(buf,0), 0);
151
152         setup_buffer(buf, seed, maxsize);
153
154         printf("Trying large write\n");
155         io.write.in.count = 4000;
156         io.write.in.offset = 0;
157         io.write.in.data = buf;
158         status = smb_raw_write(cli->tree, &io);
159         CHECK_STATUS(status, NT_STATUS_OK);
160         CHECK_VALUE(io.write.out.nwritten, 4000);
161
162         memset(buf, 0, maxsize);
163         if (smbcli_read(cli->tree, fnum, buf, 0, 4000) != 4000) {
164                 printf("read failed at %s\n", __location__);
165                 ret = False;
166                 goto done;
167         }
168         CHECK_BUFFER(buf, seed, 4000);
169
170         printf("Trying bad fnum\n");
171         io.write.in.fnum = fnum+1;
172         io.write.in.count = 4000;
173         io.write.in.offset = 0;
174         io.write.in.data = buf;
175         status = smb_raw_write(cli->tree, &io);
176         CHECK_STATUS(status, NT_STATUS_INVALID_HANDLE);
177
178         printf("Setting file as sparse\n");
179         status = torture_set_sparse(cli->tree, fnum);
180         CHECK_STATUS(status, NT_STATUS_OK);
181         
182         printf("Trying 2^32 offset\n");
183         setup_buffer(buf, seed, maxsize);
184         io.write.in.fnum = fnum;
185         io.write.in.count = 4000;
186         io.write.in.offset = 0xFFFFFFFF - 2000;
187         io.write.in.data = buf;
188         status = smb_raw_write(cli->tree, &io);
189         CHECK_STATUS(status, NT_STATUS_OK);
190         CHECK_VALUE(io.write.out.nwritten, 4000);
191         CHECK_ALL_INFO(io.write.in.count + (uint64_t)io.write.in.offset, size);
192
193         memset(buf, 0, maxsize);
194         if (smbcli_read(cli->tree, fnum, buf, io.write.in.offset, 4000) != 4000) {
195                 printf("read failed at %s\n", __location__);
196                 ret = False;
197                 goto done;
198         }
199         CHECK_BUFFER(buf, seed, 4000);
200
201 done:
202         smbcli_close(cli->tree, fnum);
203         smb_raw_exit(cli->session);
204         smbcli_deltree(cli->tree, BASEDIR);
205         return ret;
206 }
207
208
209 /*
210   test writex ops
211 */
212 static BOOL test_writex(struct smbcli_state *cli, TALLOC_CTX *mem_ctx)
213 {
214         union smb_write io;
215         NTSTATUS status;
216         BOOL ret = True;
217         int fnum, i;
218         uint8_t *buf;
219         const int maxsize = 90000;
220         const char *fname = BASEDIR "\\test.txt";
221         uint_t seed = time(NULL);
222         union smb_fileinfo finfo;
223
224         buf = talloc_zero(mem_ctx, maxsize);
225
226         if (!torture_setup_dir(cli, BASEDIR)) {
227                 return False;
228         }
229
230         printf("Testing RAW_WRITE_WRITEX\n");
231         io.generic.level = RAW_WRITE_WRITEX;
232         
233         fnum = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
234         if (fnum == -1) {
235                 printf("Failed to create %s - %s\n", fname, smbcli_errstr(cli->tree));
236                 ret = False;
237                 goto done;
238         }
239
240         printf("Trying zero write\n");
241         io.writex.in.fnum = fnum;
242         io.writex.in.offset = 0;
243         io.writex.in.wmode = 0;
244         io.writex.in.remaining = 0;
245         io.writex.in.count = 0;
246         io.writex.in.data = buf;
247         status = smb_raw_write(cli->tree, &io);
248         CHECK_STATUS(status, NT_STATUS_OK);
249         CHECK_VALUE(io.writex.out.nwritten, 0);
250
251         setup_buffer(buf, seed, maxsize);
252
253         printf("Trying small write\n");
254         io.writex.in.count = 9;
255         io.writex.in.offset = 4;
256         io.writex.in.data = buf;
257         status = smb_raw_write(cli->tree, &io);
258         CHECK_STATUS(status, NT_STATUS_OK);
259         CHECK_VALUE(io.writex.out.nwritten, io.writex.in.count);
260
261         memset(buf, 0, maxsize);
262         if (smbcli_read(cli->tree, fnum, buf, 0, 13) != 13) {
263                 printf("read failed at %s\n", __location__);
264                 ret = False;
265                 goto done;
266         }
267         CHECK_BUFFER(buf+4, seed, 9);
268         CHECK_VALUE(IVAL(buf,0), 0);
269
270         setup_buffer(buf, seed, maxsize);
271
272         printf("Trying large write\n");
273         io.writex.in.count = 4000;
274         io.writex.in.offset = 0;
275         io.writex.in.data = buf;
276         status = smb_raw_write(cli->tree, &io);
277         CHECK_STATUS(status, NT_STATUS_OK);
278         CHECK_VALUE(io.writex.out.nwritten, 4000);
279
280         memset(buf, 0, maxsize);
281         if (smbcli_read(cli->tree, fnum, buf, 0, 4000) != 4000) {
282                 printf("read failed at %s\n", __location__);
283                 ret = False;
284                 goto done;
285         }
286         CHECK_BUFFER(buf, seed, 4000);
287
288         printf("Trying bad fnum\n");
289         io.writex.in.fnum = fnum+1;
290         io.writex.in.count = 4000;
291         io.writex.in.offset = 0;
292         io.writex.in.data = buf;
293         status = smb_raw_write(cli->tree, &io);
294         CHECK_STATUS(status, NT_STATUS_INVALID_HANDLE);
295
296         printf("Testing wmode\n");
297         io.writex.in.fnum = fnum;
298         io.writex.in.count = 1;
299         io.writex.in.offset = 0;
300         io.writex.in.wmode = 1;
301         io.writex.in.data = buf;
302         status = smb_raw_write(cli->tree, &io);
303         CHECK_STATUS(status, NT_STATUS_OK);
304         CHECK_VALUE(io.writex.out.nwritten, io.writex.in.count);
305
306         io.writex.in.wmode = 2;
307         status = smb_raw_write(cli->tree, &io);
308         CHECK_STATUS(status, NT_STATUS_OK);
309         CHECK_VALUE(io.writex.out.nwritten, io.writex.in.count);
310
311
312         printf("Trying locked region\n");
313         cli->session->pid++;
314         if (NT_STATUS_IS_ERR(smbcli_lock(cli->tree, fnum, 3, 1, 0, WRITE_LOCK))) {
315                 printf("Failed to lock file at %s\n", __location__);
316                 ret = False;
317                 goto done;
318         }
319         cli->session->pid--;
320         io.writex.in.wmode = 0;
321         io.writex.in.count = 4;
322         io.writex.in.offset = 0;
323         status = smb_raw_write(cli->tree, &io);
324         CHECK_STATUS(status, NT_STATUS_FILE_LOCK_CONFLICT);
325
326         printf("Setting file as sparse\n");
327         status = torture_set_sparse(cli->tree, fnum);
328         CHECK_STATUS(status, NT_STATUS_OK);
329         
330         printf("Trying 2^32 offset\n");
331         setup_buffer(buf, seed, maxsize);
332         io.writex.in.fnum = fnum;
333         io.writex.in.count = 4000;
334         io.writex.in.offset = 0xFFFFFFFF - 2000;
335         io.writex.in.data = buf;
336         status = smb_raw_write(cli->tree, &io);
337         CHECK_STATUS(status, NT_STATUS_OK);
338         CHECK_VALUE(io.writex.out.nwritten, 4000);
339         CHECK_ALL_INFO(io.writex.in.count + (uint64_t)io.writex.in.offset, size);
340
341         memset(buf, 0, maxsize);
342         if (smbcli_read(cli->tree, fnum, buf, io.writex.in.offset, 4000) != 4000) {
343                 printf("read failed at %s\n", __location__);
344                 ret = False;
345                 goto done;
346         }
347         CHECK_BUFFER(buf, seed, 4000);
348
349         for (i=33;i<64;i++) {
350                 printf("Trying 2^%d offset\n", i);
351                 setup_buffer(buf, seed+1, maxsize);
352                 io.writex.in.fnum = fnum;
353                 io.writex.in.count = 4000;
354                 io.writex.in.offset = ((uint64_t)1) << i;
355                 io.writex.in.data = buf;
356                 status = smb_raw_write(cli->tree, &io);
357                 if (i>40 &&
358                     NT_STATUS_EQUAL(status, NT_STATUS_INVALID_PARAMETER)) {
359                         break;
360                 }
361                 CHECK_STATUS(status, NT_STATUS_OK);
362                 CHECK_VALUE(io.writex.out.nwritten, 4000);
363                 CHECK_ALL_INFO(io.writex.in.count + (uint64_t)io.writex.in.offset, size);
364
365                 memset(buf, 0, maxsize);
366                 if (smbcli_read(cli->tree, fnum, buf, io.writex.in.offset, 4000) != 4000) {
367                         printf("read failed at %s\n", __location__);
368                         ret = False;
369                         goto done;
370                 }
371                 CHECK_BUFFER(buf, seed+1, 4000);
372         }
373         printf("limit is 2^%d\n", i);
374
375         setup_buffer(buf, seed, maxsize);
376
377 done:
378         smbcli_close(cli->tree, fnum);
379         smb_raw_exit(cli->session);
380         smbcli_deltree(cli->tree, BASEDIR);
381         return ret;
382 }
383
384
385 /*
386   test write unlock ops
387 */
388 static BOOL test_writeunlock(struct smbcli_state *cli, TALLOC_CTX *mem_ctx)
389 {
390         union smb_write io;
391         NTSTATUS status;
392         BOOL ret = True;
393         int fnum;
394         uint8_t *buf;
395         const int maxsize = 90000;
396         const char *fname = BASEDIR "\\test.txt";
397         uint_t seed = time(NULL);
398         union smb_fileinfo finfo;
399
400         buf = talloc_zero(mem_ctx, maxsize);
401
402         if (!torture_setup_dir(cli, BASEDIR)) {
403                 return False;
404         }
405
406         printf("Testing RAW_WRITE_WRITEUNLOCK\n");
407         io.generic.level = RAW_WRITE_WRITEUNLOCK;
408         
409         fnum = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
410         if (fnum == -1) {
411                 printf("Failed to create %s - %s\n", fname, smbcli_errstr(cli->tree));
412                 ret = False;
413                 goto done;
414         }
415
416         printf("Trying zero write\n");
417         io.writeunlock.in.fnum = fnum;
418         io.writeunlock.in.count = 0;
419         io.writeunlock.in.offset = 0;
420         io.writeunlock.in.remaining = 0;
421         io.writeunlock.in.data = buf;
422         status = smb_raw_write(cli->tree, &io);
423         CHECK_STATUS(status, NT_STATUS_OK);
424         CHECK_VALUE(io.writeunlock.out.nwritten, io.writeunlock.in.count);
425
426         setup_buffer(buf, seed, maxsize);
427
428         printf("Trying small write\n");
429         io.writeunlock.in.count = 9;
430         io.writeunlock.in.offset = 4;
431         io.writeunlock.in.data = buf;
432         status = smb_raw_write(cli->tree, &io);
433         CHECK_STATUS(status, NT_STATUS_RANGE_NOT_LOCKED);
434         if (smbcli_read(cli->tree, fnum, buf, 0, 13) != 13) {
435                 printf("read failed at %s\n", __location__);
436                 ret = False;
437                 goto done;
438         }
439         CHECK_BUFFER(buf+4, seed, 9);
440         CHECK_VALUE(IVAL(buf,0), 0);
441
442         setup_buffer(buf, seed, maxsize);
443         smbcli_lock(cli->tree, fnum, io.writeunlock.in.offset, io.writeunlock.in.count, 
444                  0, WRITE_LOCK);
445         status = smb_raw_write(cli->tree, &io);
446         CHECK_STATUS(status, NT_STATUS_OK);
447         CHECK_VALUE(io.writeunlock.out.nwritten, io.writeunlock.in.count);
448
449         memset(buf, 0, maxsize);
450         if (smbcli_read(cli->tree, fnum, buf, 0, 13) != 13) {
451                 printf("read failed at %s\n", __location__);
452                 ret = False;
453                 goto done;
454         }
455         CHECK_BUFFER(buf+4, seed, 9);
456         CHECK_VALUE(IVAL(buf,0), 0);
457
458         setup_buffer(buf, seed, maxsize);
459
460         printf("Trying large write\n");
461         io.writeunlock.in.count = 4000;
462         io.writeunlock.in.offset = 0;
463         io.writeunlock.in.data = buf;
464         smbcli_lock(cli->tree, fnum, io.writeunlock.in.offset, io.writeunlock.in.count, 
465                  0, WRITE_LOCK);
466         status = smb_raw_write(cli->tree, &io);
467         CHECK_STATUS(status, NT_STATUS_OK);
468         CHECK_VALUE(io.writeunlock.out.nwritten, 4000);
469
470         status = smb_raw_write(cli->tree, &io);
471         CHECK_STATUS(status, NT_STATUS_RANGE_NOT_LOCKED);
472
473         memset(buf, 0, maxsize);
474         if (smbcli_read(cli->tree, fnum, buf, 0, 4000) != 4000) {
475                 printf("read failed at %s\n", __location__);
476                 ret = False;
477                 goto done;
478         }
479         CHECK_BUFFER(buf, seed, 4000);
480
481         printf("Trying bad fnum\n");
482         io.writeunlock.in.fnum = fnum+1;
483         io.writeunlock.in.count = 4000;
484         io.writeunlock.in.offset = 0;
485         io.writeunlock.in.data = buf;
486         status = smb_raw_write(cli->tree, &io);
487         CHECK_STATUS(status, NT_STATUS_INVALID_HANDLE);
488
489         printf("Setting file as sparse\n");
490         status = torture_set_sparse(cli->tree, fnum);
491         CHECK_STATUS(status, NT_STATUS_OK);
492         
493         printf("Trying 2^32 offset\n");
494         setup_buffer(buf, seed, maxsize);
495         io.writeunlock.in.fnum = fnum;
496         io.writeunlock.in.count = 4000;
497         io.writeunlock.in.offset = 0xFFFFFFFF - 2000;
498         io.writeunlock.in.data = buf;
499         smbcli_lock(cli->tree, fnum, io.writeunlock.in.offset, io.writeunlock.in.count, 
500                  0, WRITE_LOCK);
501         status = smb_raw_write(cli->tree, &io);
502         CHECK_STATUS(status, NT_STATUS_OK);
503         CHECK_VALUE(io.writeunlock.out.nwritten, 4000);
504         CHECK_ALL_INFO(io.writeunlock.in.count + (uint64_t)io.writeunlock.in.offset, size);
505
506         memset(buf, 0, maxsize);
507         if (smbcli_read(cli->tree, fnum, buf, io.writeunlock.in.offset, 4000) != 4000) {
508                 printf("read failed at %s\n", __location__);
509                 ret = False;
510                 goto done;
511         }
512         CHECK_BUFFER(buf, seed, 4000);
513
514 done:
515         smbcli_close(cli->tree, fnum);
516         smb_raw_exit(cli->session);
517         smbcli_deltree(cli->tree, BASEDIR);
518         return ret;
519 }
520
521
522 /*
523   test write close ops
524 */
525 static BOOL test_writeclose(struct smbcli_state *cli, TALLOC_CTX *mem_ctx)
526 {
527         union smb_write io;
528         NTSTATUS status;
529         BOOL ret = True;
530         int fnum;
531         uint8_t *buf;
532         const int maxsize = 90000;
533         const char *fname = BASEDIR "\\test.txt";
534         uint_t seed = time(NULL);
535         union smb_fileinfo finfo;
536
537         buf = talloc_zero(mem_ctx, maxsize);
538
539         if (!torture_setup_dir(cli, BASEDIR)) {
540                 return False;
541         }
542
543         printf("Testing RAW_WRITE_WRITECLOSE\n");
544         io.generic.level = RAW_WRITE_WRITECLOSE;
545         
546         fnum = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
547         if (fnum == -1) {
548                 printf("Failed to create %s - %s\n", fname, smbcli_errstr(cli->tree));
549                 ret = False;
550                 goto done;
551         }
552
553         printf("Trying zero write\n");
554         io.writeclose.in.fnum = fnum;
555         io.writeclose.in.count = 0;
556         io.writeclose.in.offset = 0;
557         io.writeclose.in.mtime = 0;
558         io.writeclose.in.data = buf;
559         status = smb_raw_write(cli->tree, &io);
560         CHECK_STATUS(status, NT_STATUS_OK);
561         CHECK_VALUE(io.writeclose.out.nwritten, io.writeclose.in.count);
562
563         status = smb_raw_write(cli->tree, &io);
564         CHECK_STATUS(status, NT_STATUS_OK);
565         CHECK_VALUE(io.writeclose.out.nwritten, io.writeclose.in.count);
566
567         setup_buffer(buf, seed, maxsize);
568
569         printf("Trying small write\n");
570         io.writeclose.in.count = 9;
571         io.writeclose.in.offset = 4;
572         io.writeclose.in.data = buf;
573         status = smb_raw_write(cli->tree, &io);
574         CHECK_STATUS(status, NT_STATUS_OK);
575
576         status = smb_raw_write(cli->tree, &io);
577         CHECK_STATUS(status, NT_STATUS_INVALID_HANDLE);
578
579         fnum = smbcli_open(cli->tree, fname, O_RDWR, DENY_NONE);
580         io.writeclose.in.fnum = fnum;
581
582         if (smbcli_read(cli->tree, fnum, buf, 0, 13) != 13) {
583                 printf("read failed at %s\n", __location__);
584                 ret = False;
585                 goto done;
586         }
587         CHECK_BUFFER(buf+4, seed, 9);
588         CHECK_VALUE(IVAL(buf,0), 0);
589
590         setup_buffer(buf, seed, maxsize);
591         status = smb_raw_write(cli->tree, &io);
592         CHECK_STATUS(status, NT_STATUS_OK);
593         CHECK_VALUE(io.writeclose.out.nwritten, io.writeclose.in.count);
594
595         fnum = smbcli_open(cli->tree, fname, O_RDWR, DENY_NONE);
596         io.writeclose.in.fnum = fnum;
597
598         memset(buf, 0, maxsize);
599         if (smbcli_read(cli->tree, fnum, buf, 0, 13) != 13) {
600                 printf("read failed at %s\n", __location__);
601                 ret = False;
602                 goto done;
603         }
604         CHECK_BUFFER(buf+4, seed, 9);
605         CHECK_VALUE(IVAL(buf,0), 0);
606
607         setup_buffer(buf, seed, maxsize);
608
609         printf("Trying large write\n");
610         io.writeclose.in.count = 4000;
611         io.writeclose.in.offset = 0;
612         io.writeclose.in.data = buf;
613         status = smb_raw_write(cli->tree, &io);
614         CHECK_STATUS(status, NT_STATUS_OK);
615         CHECK_VALUE(io.writeclose.out.nwritten, 4000);
616
617         status = smb_raw_write(cli->tree, &io);
618         CHECK_STATUS(status, NT_STATUS_INVALID_HANDLE);
619
620         fnum = smbcli_open(cli->tree, fname, O_RDWR, DENY_NONE);
621         io.writeclose.in.fnum = fnum;
622
623         memset(buf, 0, maxsize);
624         if (smbcli_read(cli->tree, fnum, buf, 0, 4000) != 4000) {
625                 printf("read failed at %s\n", __location__);
626                 ret = False;
627                 goto done;
628         }
629         CHECK_BUFFER(buf, seed, 4000);
630
631         printf("Trying bad fnum\n");
632         io.writeclose.in.fnum = fnum+1;
633         io.writeclose.in.count = 4000;
634         io.writeclose.in.offset = 0;
635         io.writeclose.in.data = buf;
636         status = smb_raw_write(cli->tree, &io);
637         CHECK_STATUS(status, NT_STATUS_INVALID_HANDLE);
638
639         printf("Setting file as sparse\n");
640         status = torture_set_sparse(cli->tree, fnum);
641         CHECK_STATUS(status, NT_STATUS_OK);
642         
643         printf("Trying 2^32 offset\n");
644         setup_buffer(buf, seed, maxsize);
645         io.writeclose.in.fnum = fnum;
646         io.writeclose.in.count = 4000;
647         io.writeclose.in.offset = 0xFFFFFFFF - 2000;
648         io.writeclose.in.data = buf;
649         status = smb_raw_write(cli->tree, &io);
650         CHECK_STATUS(status, NT_STATUS_OK);
651         CHECK_VALUE(io.writeclose.out.nwritten, 4000);
652         CHECK_ALL_INFO(io.writeclose.in.count + (uint64_t)io.writeclose.in.offset, size);
653
654         fnum = smbcli_open(cli->tree, fname, O_RDWR, DENY_NONE);
655         io.writeclose.in.fnum = fnum;
656
657         memset(buf, 0, maxsize);
658         if (smbcli_read(cli->tree, fnum, buf, io.writeclose.in.offset, 4000) != 4000) {
659                 printf("read failed at %s\n", __location__);
660                 ret = False;
661                 goto done;
662         }
663         CHECK_BUFFER(buf, seed, 4000);
664
665 done:
666         smbcli_close(cli->tree, fnum);
667         smb_raw_exit(cli->session);
668         smbcli_deltree(cli->tree, BASEDIR);
669         return ret;
670 }
671
672 /* 
673    basic testing of write calls
674 */
675 BOOL torture_raw_write(void)
676 {
677         struct smbcli_state *cli;
678         BOOL ret = True;
679         TALLOC_CTX *mem_ctx;
680
681         if (!torture_open_connection(&cli)) {
682                 return False;
683         }
684
685         mem_ctx = talloc_init("torture_raw_write");
686
687         ret &= test_write(cli, mem_ctx);
688         ret &= test_writeunlock(cli, mem_ctx);
689         ret &= test_writeclose(cli, mem_ctx);
690         ret &= test_writex(cli, mem_ctx);
691
692         torture_close_connection(cli);
693         talloc_destroy(mem_ctx);
694         return ret;
695 }