source4/torture/raw/write.c

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