source3/libsmb/clifile.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    client file operations
   4    Copyright (C) Andrew Tridgell 1994-1998
   5    Copyright (C) Jeremy Allison 2001-2002
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19 */
  20
  21 #include "includes.h"
  22
  23 /****************************************************************************
  24  Hard/Symlink a file (UNIX extensions).
  25  Creates new name (sym)linked to oldname.
  26 ****************************************************************************/
  27
  28 static bool cli_link_internal(struct cli_state *cli, const char *oldname, const char *newname, bool hard_link)
  29 {
  30         unsigned int data_len = 0;
  31         unsigned int param_len = 0;
  32         uint16 setup = TRANSACT2_SETPATHINFO;
  33         char *param;
  34         char *data;
  35         char *rparam=NULL, *rdata=NULL;
  36         char *p;
  37         size_t oldlen = 2*(strlen(oldname)+1);
  38         size_t newlen = 2*(strlen(newname)+1);
  39
  40         param = SMB_MALLOC_ARRAY(char, 6+newlen+2);
  41
  42         if (!param) {
  43                 return false;
  44         }
  45
  46         data = SMB_MALLOC_ARRAY(char, oldlen+2);
  47
  48         if (!data) {
  49                 SAFE_FREE(param);
  50                 return false;
  51         }
  52
  53         SSVAL(param,0,hard_link ? SMB_SET_FILE_UNIX_HLINK : SMB_SET_FILE_UNIX_LINK);
  54         SIVAL(param,2,0);
  55         p = &param[6];
  56
  57         p += clistr_push(cli, p, newname, newlen, STR_TERMINATE);
  58         param_len = PTR_DIFF(p, param);
  59
  60         p = data;
  61         p += clistr_push(cli, p, oldname, oldlen, STR_TERMINATE);
  62         data_len = PTR_DIFF(p, data);
  63
  64         if (!cli_send_trans(cli, SMBtrans2,
  65                         NULL,                        /* name */
  66                         -1, 0,                          /* fid, flags */
  67                         &setup, 1, 0,                   /* setup, length, max */
  68                         param, param_len, 2,            /* param, length, max */
  69                         data,  data_len, cli->max_xmit /* data, length, max */
  70                         )) {
  71                 SAFE_FREE(data);
  72                 SAFE_FREE(param);
  73                 return false;
  74         }
  75
  76         SAFE_FREE(data);
  77         SAFE_FREE(param);
  78
  79         if (!cli_receive_trans(cli, SMBtrans2,
  80                         &rparam, &param_len,
  81                         &rdata, &data_len)) {
  82                         return false;
  83         }
  84
  85         SAFE_FREE(data);
  86         SAFE_FREE(param);
  87         SAFE_FREE(rdata);
  88         SAFE_FREE(rparam);
  89
  90         return true;
  91 }
  92
  93 /****************************************************************************
  94  Map standard UNIX permissions onto wire representations.
  95 ****************************************************************************/
  96
  97 uint32 unix_perms_to_wire(mode_t perms)
  98 {
  99         unsigned int ret = 0;
 100
 101         ret |= ((perms & S_IXOTH) ?  UNIX_X_OTH : 0);
 102         ret |= ((perms & S_IWOTH) ?  UNIX_W_OTH : 0);
 103         ret |= ((perms & S_IROTH) ?  UNIX_R_OTH : 0);
 104         ret |= ((perms & S_IXGRP) ?  UNIX_X_GRP : 0);
 105         ret |= ((perms & S_IWGRP) ?  UNIX_W_GRP : 0);
 106         ret |= ((perms & S_IRGRP) ?  UNIX_R_GRP : 0);
 107         ret |= ((perms & S_IXUSR) ?  UNIX_X_USR : 0);
 108         ret |= ((perms & S_IWUSR) ?  UNIX_W_USR : 0);
 109         ret |= ((perms & S_IRUSR) ?  UNIX_R_USR : 0);
 110 #ifdef S_ISVTX
 111         ret |= ((perms & S_ISVTX) ?  UNIX_STICKY : 0);
 112 #endif
 113 #ifdef S_ISGID
 114         ret |= ((perms & S_ISGID) ?  UNIX_SET_GID : 0);
 115 #endif
 116 #ifdef S_ISUID
 117         ret |= ((perms & S_ISUID) ?  UNIX_SET_UID : 0);
 118 #endif
 119         return ret;
 120 }
 121
 122 /****************************************************************************
 123  Map wire permissions to standard UNIX.
 124 ****************************************************************************/
 125
 126 mode_t wire_perms_to_unix(uint32 perms)
 127 {
 128         mode_t ret = (mode_t)0;
 129
 130         ret |= ((perms & UNIX_X_OTH) ? S_IXOTH : 0);
 131         ret |= ((perms & UNIX_W_OTH) ? S_IWOTH : 0);
 132         ret |= ((perms & UNIX_R_OTH) ? S_IROTH : 0);
 133         ret |= ((perms & UNIX_X_GRP) ? S_IXGRP : 0);
 134         ret |= ((perms & UNIX_W_GRP) ? S_IWGRP : 0);
 135         ret |= ((perms & UNIX_R_GRP) ? S_IRGRP : 0);
 136         ret |= ((perms & UNIX_X_USR) ? S_IXUSR : 0);
 137         ret |= ((perms & UNIX_W_USR) ? S_IWUSR : 0);
 138         ret |= ((perms & UNIX_R_USR) ? S_IRUSR : 0);
 139 #ifdef S_ISVTX
 140         ret |= ((perms & UNIX_STICKY) ? S_ISVTX : 0);
 141 #endif
 142 #ifdef S_ISGID
 143         ret |= ((perms & UNIX_SET_GID) ? S_ISGID : 0);
 144 #endif
 145 #ifdef S_ISUID
 146         ret |= ((perms & UNIX_SET_UID) ? S_ISUID : 0);
 147 #endif
 148         return ret;
 149 }
 150
 151 /****************************************************************************
 152  Return the file type from the wire filetype for UNIX extensions.
 153 ****************************************************************************/
 154
 155 static mode_t unix_filetype_from_wire(uint32 wire_type)
 156 {
 157         switch (wire_type) {
 158                 case UNIX_TYPE_FILE:
 159                         return S_IFREG;
 160                 case UNIX_TYPE_DIR:
 161                         return S_IFDIR;
 162 #ifdef S_IFLNK
 163                 case UNIX_TYPE_SYMLINK:
 164                         return S_IFLNK;
 165 #endif
 166 #ifdef S_IFCHR
 167                 case UNIX_TYPE_CHARDEV:
 168                         return S_IFCHR;
 169 #endif
 170 #ifdef S_IFBLK
 171                 case UNIX_TYPE_BLKDEV:
 172                         return S_IFBLK;
 173 #endif
 174 #ifdef S_IFIFO
 175                 case UNIX_TYPE_FIFO:
 176                         return S_IFIFO;
 177 #endif
 178 #ifdef S_IFSOCK
 179                 case UNIX_TYPE_SOCKET:
 180                         return S_IFSOCK;
 181 #endif
 182                 default:
 183                         return (mode_t)0;
 184         }
 185 }
 186
 187 /****************************************************************************
 188  Do a POSIX getfacl (UNIX extensions).
 189 ****************************************************************************/
 190
 191 bool cli_unix_getfacl(struct cli_state *cli, const char *name, size_t *prb_size, char **retbuf)
 192 {
 193         unsigned int param_len = 0;
 194         unsigned int data_len = 0;
 195         uint16 setup = TRANSACT2_QPATHINFO;
 196         char *param;
 197         size_t nlen = 2*(strlen(name)+1);
 198         char *rparam=NULL, *rdata=NULL;
 199         char *p;
 200
 201         param = SMB_MALLOC_ARRAY(char, 6+nlen+2);
 202         if (!param) {
 203                 return false;
 204         }
 205
 206         p = param;
 207         memset(p, '\0', 6);
 208         SSVAL(p, 0, SMB_QUERY_POSIX_ACL);
 209         p += 6;
 210         p += clistr_push(cli, p, name, nlen, STR_TERMINATE);
 211         param_len = PTR_DIFF(p, param);
 212
 213         if (!cli_send_trans(cli, SMBtrans2,
 214                 NULL,                        /* name */
 215                 -1, 0,                       /* fid, flags */
 216                 &setup, 1, 0,                /* setup, length, max */
 217                 param, param_len, 2,         /* param, length, max */
 218                 NULL,  0, cli->max_xmit      /* data, length, max */
 219                 )) {
 220                 SAFE_FREE(param);
 221                 return false;
 222         }
 223
 224         SAFE_FREE(param);
 225
 226         if (!cli_receive_trans(cli, SMBtrans2,
 227                         &rparam, &param_len,
 228                         &rdata, &data_len)) {
 229                 return false;
 230         }
 231
 232         if (data_len < 6) {
 233                 SAFE_FREE(rdata);
 234                 SAFE_FREE(rparam);
 235                 return false;
 236         }
 237
 238         SAFE_FREE(rparam);
 239         *retbuf = rdata;
 240         *prb_size = (size_t)data_len;
 241
 242         return true;
 243 }
 244
 245 /****************************************************************************
 246  Stat a file (UNIX extensions).
 247 ****************************************************************************/
 248
 249 bool cli_unix_stat(struct cli_state *cli, const char *name, SMB_STRUCT_STAT *sbuf)
 250 {
 251         unsigned int param_len = 0;
 252         unsigned int data_len = 0;
 253         uint16 setup = TRANSACT2_QPATHINFO;
 254         char *param;
 255         size_t nlen = 2*(strlen(name)+1);
 256         char *rparam=NULL, *rdata=NULL;
 257         char *p;
 258
 259         ZERO_STRUCTP(sbuf);
 260
 261         param = SMB_MALLOC_ARRAY(char, 6+nlen+2);
 262         if (!param) {
 263                 return false;
 264         }
 265         p = param;
 266         memset(p, '\0', 6);
 267         SSVAL(p, 0, SMB_QUERY_FILE_UNIX_BASIC);
 268         p += 6;
 269         p += clistr_push(cli, p, name, nlen, STR_TERMINATE);
 270         param_len = PTR_DIFF(p, param);
 271
 272         if (!cli_send_trans(cli, SMBtrans2,
 273                         NULL,                        /* name */
 274                         -1, 0,                       /* fid, flags */
 275                         &setup, 1, 0,                /* setup, length, max */
 276                         param, param_len, 2,         /* param, length, max */
 277                         NULL,  0, cli->max_xmit      /* data, length, max */
 278                         )) {
 279                 SAFE_FREE(param);
 280                 return false;
 281         }
 282
 283         SAFE_FREE(param);
 284
 285         if (!cli_receive_trans(cli, SMBtrans2,
 286                         &rparam, &param_len,
 287                         &rdata, &data_len)) {
 288                 return false;
 289         }
 290
 291         if (data_len < 96) {
 292                 SAFE_FREE(rdata);
 293                 SAFE_FREE(rparam);
 294                 return false;
 295         }
 296
 297         sbuf->st_size = IVAL2_TO_SMB_BIG_UINT(rdata,0);     /* total size, in bytes */
 298         sbuf->st_blocks = IVAL2_TO_SMB_BIG_UINT(rdata,8);   /* number of blocks allocated */
 299 #if defined (HAVE_STAT_ST_BLOCKS) && defined(STAT_ST_BLOCKSIZE)
 300         sbuf->st_blocks /= STAT_ST_BLOCKSIZE;
 301 #else
 302         /* assume 512 byte blocks */
 303         sbuf->st_blocks /= 512;
 304 #endif
 305         set_ctimespec(sbuf, interpret_long_date(rdata + 16));    /* time of last change */
 306         set_atimespec(sbuf, interpret_long_date(rdata + 24));    /* time of last access */
 307         set_mtimespec(sbuf, interpret_long_date(rdata + 32));    /* time of last modification */
 308
 309         sbuf->st_uid = (uid_t) IVAL(rdata,40);      /* user ID of owner */
 310         sbuf->st_gid = (gid_t) IVAL(rdata,48);      /* group ID of owner */
 311         sbuf->st_mode |= unix_filetype_from_wire(IVAL(rdata, 56));
 312 #if defined(HAVE_MAKEDEV)
 313         {
 314                 uint32 dev_major = IVAL(rdata,60);
 315                 uint32 dev_minor = IVAL(rdata,68);
 316                 sbuf->st_rdev = makedev(dev_major, dev_minor);
 317         }
 318 #endif
 319         sbuf->st_ino = (SMB_INO_T)IVAL2_TO_SMB_BIG_UINT(rdata,76);      /* inode */
 320         sbuf->st_mode |= wire_perms_to_unix(IVAL(rdata,84));     /* protection */
 321         sbuf->st_nlink = IVAL(rdata,92);    /* number of hard links */
 322
 323         SAFE_FREE(rdata);
 324         SAFE_FREE(rparam);
 325
 326         return true;
 327 }
 328
 329 /****************************************************************************
 330  Symlink a file (UNIX extensions).
 331 ****************************************************************************/
 332
 333 bool cli_unix_symlink(struct cli_state *cli, const char *oldname, const char *newname)
 334 {
 335         return cli_link_internal(cli, oldname, newname, False);
 336 }
 337
 338 /****************************************************************************
 339  Hard a file (UNIX extensions).
 340 ****************************************************************************/
 341
 342 bool cli_unix_hardlink(struct cli_state *cli, const char *oldname, const char *newname)
 343 {
 344         return cli_link_internal(cli, oldname, newname, True);
 345 }
 346
 347 /****************************************************************************
 348  Chmod or chown a file internal (UNIX extensions).
 349 ****************************************************************************/
 350
 351 static bool cli_unix_chmod_chown_internal(struct cli_state *cli, const char *fname, uint32 mode, uint32 uid, uint32 gid)
 352 {
 353         unsigned int data_len = 0;
 354         unsigned int param_len = 0;
 355         uint16 setup = TRANSACT2_SETPATHINFO;
 356         size_t nlen = 2*(strlen(fname)+1);
 357         char *param;
 358         char data[100];
 359         char *rparam=NULL, *rdata=NULL;
 360         char *p;
 361
 362         param = SMB_MALLOC_ARRAY(char, 6+nlen+2);
 363         if (!param) {
 364                 return false;
 365         }
 366         memset(param, '\0', 6);
 367         memset(data, 0, sizeof(data));
 368
 369         SSVAL(param,0,SMB_SET_FILE_UNIX_BASIC);
 370         p = &param[6];
 371
 372         p += clistr_push(cli, p, fname, nlen, STR_TERMINATE);
 373         param_len = PTR_DIFF(p, param);
 374
 375         memset(data, 0xff, 40); /* Set all sizes/times to no change. */
 376
 377         SIVAL(data,40,uid);
 378         SIVAL(data,48,gid);
 379         SIVAL(data,84,mode);
 380
 381         data_len = 100;
 382
 383         if (!cli_send_trans(cli, SMBtrans2,
 384                         NULL,                        /* name */
 385                         -1, 0,                          /* fid, flags */
 386                         &setup, 1, 0,                   /* setup, length, max */
 387                         param, param_len, 2,            /* param, length, max */
 388                         (char *)&data,  data_len, cli->max_xmit /* data, length, max */
 389                         )) {
 390                 SAFE_FREE(param);
 391                 return False;
 392         }
 393
 394         SAFE_FREE(param);
 395
 396         if (!cli_receive_trans(cli, SMBtrans2,
 397                         &rparam, &param_len,
 398                         &rdata, &data_len)) {
 399                 return false;
 400         }
 401
 402         SAFE_FREE(rdata);
 403         SAFE_FREE(rparam);
 404
 405         return true;
 406 }
 407
 408 /****************************************************************************
 409  chmod a file (UNIX extensions).
 410 ****************************************************************************/
 411
 412 bool cli_unix_chmod(struct cli_state *cli, const char *fname, mode_t mode)
 413 {
 414         return cli_unix_chmod_chown_internal(cli, fname,
 415                 unix_perms_to_wire(mode), SMB_UID_NO_CHANGE, SMB_GID_NO_CHANGE);
 416 }
 417
 418 /****************************************************************************
 419  chown a file (UNIX extensions).
 420 ****************************************************************************/
 421
 422 bool cli_unix_chown(struct cli_state *cli, const char *fname, uid_t uid, gid_t gid)
 423 {
 424         return cli_unix_chmod_chown_internal(cli, fname,
 425                         SMB_MODE_NO_CHANGE, (uint32)uid, (uint32)gid);
 426 }
 427
 428 /****************************************************************************
 429  Rename a file.
 430 ****************************************************************************/
 431
 432 bool cli_rename(struct cli_state *cli, const char *fname_src, const char *fname_dst)
 433 {
 434         char *p;
 435
 436         memset(cli->outbuf,'\0',smb_size);
 437         memset(cli->inbuf,'\0',smb_size);
 438
 439         cli_set_message(cli->outbuf,1, 0, true);
 440
 441         SCVAL(cli->outbuf,smb_com,SMBmv);
 442         SSVAL(cli->outbuf,smb_tid,cli->cnum);
 443         cli_setup_packet(cli);
 444
 445         SSVAL(cli->outbuf,smb_vwv0,aSYSTEM | aHIDDEN | aDIR);
 446
 447         p = smb_buf(cli->outbuf);
 448         *p++ = 4;
 449         p += clistr_push(cli, p, fname_src,
 450                         cli->bufsize - PTR_DIFF(p,cli->outbuf), STR_TERMINATE);
 451         *p++ = 4;
 452         p += clistr_push(cli, p, fname_dst,
 453                         cli->bufsize - PTR_DIFF(p,cli->outbuf), STR_TERMINATE);
 454
 455         cli_setup_bcc(cli, p);
 456
 457         cli_send_smb(cli);
 458         if (!cli_receive_smb(cli)) {
 459                 return false;
 460         }
 461
 462         if (cli_is_error(cli)) {
 463                 return false;
 464         }
 465
 466         return true;
 467 }
 468
 469 /****************************************************************************
 470  NT Rename a file.
 471 ****************************************************************************/
 472
 473 bool cli_ntrename(struct cli_state *cli, const char *fname_src, const char *fname_dst)
 474 {
 475         char *p;
 476
 477         memset(cli->outbuf,'\0',smb_size);
 478         memset(cli->inbuf,'\0',smb_size);
 479
 480         cli_set_message(cli->outbuf, 4, 0, true);
 481
 482         SCVAL(cli->outbuf,smb_com,SMBntrename);
 483         SSVAL(cli->outbuf,smb_tid,cli->cnum);
 484         cli_setup_packet(cli);
 485
 486         SSVAL(cli->outbuf,smb_vwv0,aSYSTEM | aHIDDEN | aDIR);
 487         SSVAL(cli->outbuf,smb_vwv1, RENAME_FLAG_RENAME);
 488
 489         p = smb_buf(cli->outbuf);
 490         *p++ = 4;
 491         p += clistr_push(cli, p, fname_src,
 492                         cli->bufsize - PTR_DIFF(p,cli->outbuf), STR_TERMINATE);
 493         *p++ = 4;
 494         p += clistr_push(cli, p, fname_dst,
 495                         cli->bufsize - PTR_DIFF(p,cli->outbuf), STR_TERMINATE);
 496
 497         cli_setup_bcc(cli, p);
 498
 499         cli_send_smb(cli);
 500         if (!cli_receive_smb(cli)) {
 501                 return false;
 502         }
 503
 504         if (cli_is_error(cli)) {
 505                 return false;
 506         }
 507
 508         return true;
 509 }
 510
 511 /****************************************************************************
 512  NT hardlink a file.
 513 ****************************************************************************/
 514
 515 bool cli_nt_hardlink(struct cli_state *cli, const char *fname_src, const char *fname_dst)
 516 {
 517         char *p;
 518
 519         memset(cli->outbuf,'\0',smb_size);
 520         memset(cli->inbuf,'\0',smb_size);
 521
 522         cli_set_message(cli->outbuf, 4, 0, true);
 523
 524         SCVAL(cli->outbuf,smb_com,SMBntrename);
 525         SSVAL(cli->outbuf,smb_tid,cli->cnum);
 526         cli_setup_packet(cli);
 527
 528         SSVAL(cli->outbuf,smb_vwv0,aSYSTEM | aHIDDEN | aDIR);
 529         SSVAL(cli->outbuf,smb_vwv1, RENAME_FLAG_HARD_LINK);
 530
 531         p = smb_buf(cli->outbuf);
 532         *p++ = 4;
 533         p += clistr_push(cli, p, fname_src,
 534                         cli->bufsize - PTR_DIFF(p,cli->outbuf), STR_TERMINATE);
 535         *p++ = 4;
 536         p += clistr_push(cli, p, fname_dst,
 537                         cli->bufsize - PTR_DIFF(p,cli->outbuf), STR_TERMINATE);
 538
 539         cli_setup_bcc(cli, p);
 540
 541         cli_send_smb(cli);
 542         if (!cli_receive_smb(cli)) {
 543                 return false;
 544         }
 545
 546         if (cli_is_error(cli)) {
 547                 return false;
 548         }
 549
 550         return true;
 551 }
 552
 553 /****************************************************************************
 554  Delete a file.
 555 ****************************************************************************/
 556
 557 bool cli_unlink_full(struct cli_state *cli, const char *fname, uint16 attrs)
 558 {
 559         char *p;
 560
 561         memset(cli->outbuf,'\0',smb_size);
 562         memset(cli->inbuf,'\0',smb_size);
 563
 564         cli_set_message(cli->outbuf,1, 0, true);
 565
 566         SCVAL(cli->outbuf,smb_com,SMBunlink);
 567         SSVAL(cli->outbuf,smb_tid,cli->cnum);
 568         cli_setup_packet(cli);
 569
 570         SSVAL(cli->outbuf,smb_vwv0, attrs);
 571
 572         p = smb_buf(cli->outbuf);
 573         *p++ = 4;
 574         p += clistr_push(cli, p, fname,
 575                         cli->bufsize - PTR_DIFF(p,cli->outbuf), STR_TERMINATE);
 576
 577         cli_setup_bcc(cli, p);
 578         cli_send_smb(cli);
 579         if (!cli_receive_smb(cli)) {
 580                 return false;
 581         }
 582
 583         if (cli_is_error(cli)) {
 584                 return false;
 585         }
 586
 587         return true;
 588 }
 589
 590 /****************************************************************************
 591  Delete a file.
 592 ****************************************************************************/
 593
 594 bool cli_unlink(struct cli_state *cli, const char *fname)
 595 {
 596         return cli_unlink_full(cli, fname, aSYSTEM | aHIDDEN);
 597 }
 598
 599 /****************************************************************************
 600  Create a directory.
 601 ****************************************************************************/
 602
 603 bool cli_mkdir(struct cli_state *cli, const char *dname)
 604 {
 605         char *p;
 606
 607         memset(cli->outbuf,'\0',smb_size);
 608         memset(cli->inbuf,'\0',smb_size);
 609
 610         cli_set_message(cli->outbuf,0, 0, true);
 611
 612         SCVAL(cli->outbuf,smb_com,SMBmkdir);
 613         SSVAL(cli->outbuf,smb_tid,cli->cnum);
 614         cli_setup_packet(cli);
 615
 616         p = smb_buf(cli->outbuf);
 617         *p++ = 4;
 618         p += clistr_push(cli, p, dname,
 619                         cli->bufsize - PTR_DIFF(p,cli->outbuf), STR_TERMINATE);
 620
 621         cli_setup_bcc(cli, p);
 622
 623         cli_send_smb(cli);
 624         if (!cli_receive_smb(cli)) {
 625                 return False;
 626         }
 627
 628         if (cli_is_error(cli)) {
 629                 return False;
 630         }
 631
 632         return True;
 633 }
 634
 635 /****************************************************************************
 636  Remove a directory.
 637 ****************************************************************************/
 638
 639 bool cli_rmdir(struct cli_state *cli, const char *dname)
 640 {
 641         char *p;
 642
 643         memset(cli->outbuf,'\0',smb_size);
 644         memset(cli->inbuf,'\0',smb_size);
 645
 646         cli_set_message(cli->outbuf,0, 0, true);
 647
 648         SCVAL(cli->outbuf,smb_com,SMBrmdir);
 649         SSVAL(cli->outbuf,smb_tid,cli->cnum);
 650         cli_setup_packet(cli);
 651
 652         p = smb_buf(cli->outbuf);
 653         *p++ = 4;
 654         p += clistr_push(cli, p, dname,
 655                         cli->bufsize - PTR_DIFF(p,cli->outbuf), STR_TERMINATE);
 656
 657         cli_setup_bcc(cli, p);
 658
 659         cli_send_smb(cli);
 660         if (!cli_receive_smb(cli)) {
 661                 return false;
 662         }
 663
 664         if (cli_is_error(cli)) {
 665                 return false;
 666         }
 667
 668         return true;
 669 }
 670
 671 /****************************************************************************
 672  Set or clear the delete on close flag.
 673 ****************************************************************************/
 674
 675 int cli_nt_delete_on_close(struct cli_state *cli, int fnum, bool flag)
 676 {
 677         unsigned int data_len = 1;
 678         unsigned int param_len = 6;
 679         uint16 setup = TRANSACT2_SETFILEINFO;
 680         char param[6];
 681         unsigned char data;
 682         char *rparam=NULL, *rdata=NULL;
 683
 684         memset(param, 0, param_len);
 685         SSVAL(param,0,fnum);
 686         SSVAL(param,2,SMB_SET_FILE_DISPOSITION_INFO);
 687
 688         data = flag ? 1 : 0;
 689
 690         if (!cli_send_trans(cli, SMBtrans2,
 691                         NULL,                        /* name */
 692                         -1, 0,                          /* fid, flags */
 693                         &setup, 1, 0,                   /* setup, length, max */
 694                         param, param_len, 2,            /* param, length, max */
 695                         (char *)&data,  data_len, cli->max_xmit /* data, length, max */
 696                         )) {
 697                 return false;
 698         }
 699
 700         if (!cli_receive_trans(cli, SMBtrans2,
 701                         &rparam, &param_len,
 702                         &rdata, &data_len)) {
 703                 return false;
 704         }
 705
 706         SAFE_FREE(rdata);
 707         SAFE_FREE(rparam);
 708
 709         return true;
 710 }
 711
 712 /****************************************************************************
 713  Open a file - exposing the full horror of the NT API :-).
 714  Used in smbtorture.
 715 ****************************************************************************/
 716
 717 int cli_nt_create_full(struct cli_state *cli, const char *fname,
 718                        uint32 CreatFlags, uint32 DesiredAccess,
 719                        uint32 FileAttributes, uint32 ShareAccess,
 720                        uint32 CreateDisposition, uint32 CreateOptions,
 721                        uint8 SecurityFlags)
 722 {
 723         char *p;
 724         int len;
 725
 726         memset(cli->outbuf,'\0',smb_size);
 727         memset(cli->inbuf,'\0',smb_size);
 728
 729         cli_set_message(cli->outbuf,24,0, true);
 730
 731         SCVAL(cli->outbuf,smb_com,SMBntcreateX);
 732         SSVAL(cli->outbuf,smb_tid,cli->cnum);
 733         cli_setup_packet(cli);
 734
 735         SSVAL(cli->outbuf,smb_vwv0,0xFF);
 736         if (cli->use_oplocks)
 737                 CreatFlags |= (REQUEST_OPLOCK|REQUEST_BATCH_OPLOCK);
 738
 739         SIVAL(cli->outbuf,smb_ntcreate_Flags, CreatFlags);
 740         SIVAL(cli->outbuf,smb_ntcreate_RootDirectoryFid, 0x0);
 741         SIVAL(cli->outbuf,smb_ntcreate_DesiredAccess, DesiredAccess);
 742         SIVAL(cli->outbuf,smb_ntcreate_FileAttributes, FileAttributes);
 743         SIVAL(cli->outbuf,smb_ntcreate_ShareAccess, ShareAccess);
 744         SIVAL(cli->outbuf,smb_ntcreate_CreateDisposition, CreateDisposition);
 745         SIVAL(cli->outbuf,smb_ntcreate_CreateOptions, CreateOptions);
 746         SIVAL(cli->outbuf,smb_ntcreate_ImpersonationLevel, 0x02);
 747         SCVAL(cli->outbuf,smb_ntcreate_SecurityFlags, SecurityFlags);
 748
 749         p = smb_buf(cli->outbuf);
 750         /* this alignment and termination is critical for netapp filers. Don't change */
 751         p += clistr_align_out(cli, p, 0);
 752         len = clistr_push(cli, p, fname,
 753                         cli->bufsize - PTR_DIFF(p,cli->outbuf), 0);
 754         p += len;
 755         SSVAL(cli->outbuf,smb_ntcreate_NameLength, len);
 756         /* sigh. this copes with broken netapp filer behaviour */
 757         p += clistr_push(cli, p, "",
 758                         cli->bufsize - PTR_DIFF(p,cli->outbuf), STR_TERMINATE);
 759
 760         cli_setup_bcc(cli, p);
 761
 762         cli_send_smb(cli);
 763         if (!cli_receive_smb(cli)) {
 764                 return -1;
 765         }
 766
 767         if (cli_is_error(cli)) {
 768                 return -1;
 769         }
 770
 771         return SVAL(cli->inbuf,smb_vwv2 + 1);
 772 }
 773
 774 struct cli_ntcreate_state {
 775         uint16_t vwv[24];
 776         uint16_t fnum;
 777 };
 778
 779 static void cli_ntcreate_done(struct tevent_req *subreq);
 780
 781 struct tevent_req *cli_ntcreate_send(TALLOC_CTX *mem_ctx,
 782                                      struct event_context *ev,
 783                                      struct cli_state *cli,
 784                                      const char *fname,
 785                                      uint32_t CreatFlags,
 786                                      uint32_t DesiredAccess,
 787                                      uint32_t FileAttributes,
 788                                      uint32_t ShareAccess,
 789                                      uint32_t CreateDisposition,
 790                                      uint32_t CreateOptions,
 791                                      uint8_t SecurityFlags)
 792 {
 793         struct tevent_req *req, *subreq;
 794         struct cli_ntcreate_state *state;
 795         uint16_t *vwv;
 796         uint8_t *bytes;
 797         size_t converted_len;
 798
 799         req = tevent_req_create(mem_ctx, &state, struct cli_ntcreate_state);
 800         if (req == NULL) {
 801                 return NULL;
 802         }
 803         vwv = state->vwv;
 804
 805         SCVAL(vwv+0, 0, 0xFF);
 806         SCVAL(vwv+0, 1, 0);
 807         SSVAL(vwv+1, 0, 0);
 808         SCVAL(vwv+2, 0, 0);
 809
 810         if (cli->use_oplocks) {
 811                 CreatFlags |= (REQUEST_OPLOCK|REQUEST_BATCH_OPLOCK);
 812         }
 813         SIVAL(vwv+3, 1, CreatFlags);
 814         SIVAL(vwv+5, 1, 0x0);   /* RootDirectoryFid */
 815         SIVAL(vwv+7, 1, DesiredAccess);
 816         SIVAL(vwv+9, 1, 0x0);   /* AllocationSize */
 817         SIVAL(vwv+11, 1, 0x0);  /* AllocationSize */
 818         SIVAL(vwv+13, 1, FileAttributes);
 819         SIVAL(vwv+15, 1, ShareAccess);
 820         SIVAL(vwv+17, 1, CreateDisposition);
 821         SIVAL(vwv+19, 1, CreateOptions);
 822         SIVAL(vwv+21, 1, 0x02); /* ImpersonationLevel */
 823         SCVAL(vwv+23, 1, SecurityFlags);
 824
 825         bytes = talloc_array(state, uint8_t, 0);
 826         bytes = smb_bytes_push_str(bytes, cli_ucs2(cli),
 827                                    fname, strlen(fname)+1,
 828                                    &converted_len);
 829
 830         /* sigh. this copes with broken netapp filer behaviour */
 831         bytes = smb_bytes_push_str(bytes, cli_ucs2(cli), "", 1, NULL);
 832
 833         if (tevent_req_nomem(bytes, req)) {
 834                 return tevent_req_post(req, ev);
 835         }
 836
 837         SIVAL(vwv+2, 1, converted_len);
 838
 839         subreq = cli_smb_send(state, ev, cli, SMBntcreateX, 0, 24, vwv,
 840                               talloc_get_size(bytes), bytes);
 841         if (tevent_req_nomem(subreq, req)) {
 842                 return tevent_req_post(req, ev);
 843         }
 844         tevent_req_set_callback(subreq, cli_ntcreate_done, req);
 845         return req;
 846 }
 847
 848 static void cli_ntcreate_done(struct tevent_req *subreq)
 849 {
 850         struct tevent_req *req = tevent_req_callback_data(
 851                 subreq, struct tevent_req);
 852         struct cli_ntcreate_state *state = tevent_req_data(
 853                 req, struct cli_ntcreate_state);
 854         uint8_t wct;
 855         uint16_t *vwv;
 856         uint32_t num_bytes;
 857         uint8_t *bytes;
 858         NTSTATUS status;
 859
 860         status = cli_smb_recv(subreq, 3, &wct, &vwv, &num_bytes, &bytes);
 861         if (!NT_STATUS_IS_OK(status)) {
 862                 TALLOC_FREE(subreq);
 863                 tevent_req_nterror(req, status);
 864                 return;
 865         }
 866         state->fnum = SVAL(vwv+2, 1);
 867         tevent_req_done(req);
 868 }
 869
 870 NTSTATUS cli_ntcreate_recv(struct tevent_req *req, uint16_t *pfnum)
 871 {
 872         struct cli_ntcreate_state *state = tevent_req_data(
 873                 req, struct cli_ntcreate_state);
 874         NTSTATUS status;
 875
 876         if (tevent_req_is_nterror(req, &status)) {
 877                 return status;
 878         }
 879         *pfnum = state->fnum;
 880         return NT_STATUS_OK;
 881 }
 882
 883 NTSTATUS cli_ntcreate(struct cli_state *cli,
 884                       const char *fname,
 885                       uint32_t CreatFlags,
 886                       uint32_t DesiredAccess,
 887                       uint32_t FileAttributes,
 888                       uint32_t ShareAccess,
 889                       uint32_t CreateDisposition,
 890                       uint32_t CreateOptions,
 891                       uint8_t SecurityFlags,
 892                       uint16_t *pfid)
 893 {
 894         TALLOC_CTX *frame = talloc_stackframe();
 895         struct event_context *ev;
 896         struct tevent_req *req;
 897         NTSTATUS status = NT_STATUS_OK;
 898
 899         if (cli_has_async_calls(cli)) {
 900                 /*
 901                  * Can't use sync call while an async call is in flight
 902                  */
 903                 status = NT_STATUS_INVALID_PARAMETER;
 904                 goto fail;
 905         }
 906
 907         ev = event_context_init(frame);
 908         if (ev == NULL) {
 909                 status = NT_STATUS_NO_MEMORY;
 910                 goto fail;
 911         }
 912
 913         req = cli_ntcreate_send(frame, ev, cli, fname, CreatFlags,
 914                                 DesiredAccess, FileAttributes, ShareAccess,
 915                                 CreateDisposition, CreateOptions,
 916                                 SecurityFlags);
 917         if (req == NULL) {
 918                 status = NT_STATUS_NO_MEMORY;
 919                 goto fail;
 920         }
 921
 922         if (!tevent_req_poll(req, ev)) {
 923                 status = map_nt_error_from_unix(errno);
 924                 goto fail;
 925         }
 926
 927         status = cli_ntcreate_recv(req, pfid);
 928  fail:
 929         TALLOC_FREE(frame);
 930         if (!NT_STATUS_IS_OK(status)) {
 931                 cli_set_error(cli, status);
 932         }
 933         return status;
 934 }
 935
 936 /****************************************************************************
 937  Open a file.
 938 ****************************************************************************/
 939
 940 int cli_nt_create(struct cli_state *cli, const char *fname, uint32 DesiredAccess)
 941 {
 942         return cli_nt_create_full(cli, fname, 0, DesiredAccess, 0,
 943                                 FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OPEN, 0x0, 0x0);
 944 }
 945
 946 uint8_t *smb_bytes_push_str(uint8_t *buf, bool ucs2,
 947                             const char *str, size_t str_len,
 948                             size_t *pconverted_size)
 949 {
 950         size_t buflen;
 951         char *converted;
 952         size_t converted_size;
 953
 954         if (buf == NULL) {
 955                 return NULL;
 956         }
 957
 958         buflen = talloc_get_size(buf);
 959         /*
 960          * We're pushing into an SMB buffer, align odd
 961          */
 962         if (ucs2 && (buflen % 2 == 0)) {
 963                 buf = TALLOC_REALLOC_ARRAY(NULL, buf, uint8_t, buflen + 1);
 964                 if (buf == NULL) {
 965                         return NULL;
 966                 }
 967                 buf[buflen] = '\0';
 968                 buflen += 1;
 969         }
 970
 971         if (!convert_string_allocate(talloc_tos(), CH_UNIX,
 972                                      ucs2 ? CH_UTF16LE : CH_DOS,
 973                                      str, str_len, &converted,
 974                                      &converted_size, true)) {
 975                 return NULL;
 976         }
 977
 978         buf = TALLOC_REALLOC_ARRAY(NULL, buf, uint8_t,
 979                                    buflen + converted_size);
 980         if (buf == NULL) {
 981                 TALLOC_FREE(converted);
 982                 return NULL;
 983         }
 984
 985         memcpy(buf + buflen, converted, converted_size);
 986
 987         TALLOC_FREE(converted);
 988
 989         if (pconverted_size) {
 990                 *pconverted_size = converted_size;
 991         }
 992
 993         return buf;
 994 }
 995
 996 /****************************************************************************
 997  Open a file
 998  WARNING: if you open with O_WRONLY then getattrE won't work!
 999 ****************************************************************************/
1000
1001 struct cli_open_state {
1002         uint16_t vwv[15];
1003         int fnum;
1004         struct iovec bytes;
1005 };
1006
1007 static void cli_open_done(struct tevent_req *subreq);
1008
1009 struct tevent_req *cli_open_create(TALLOC_CTX *mem_ctx,
1010                                    struct event_context *ev,
1011                                    struct cli_state *cli, const char *fname,
1012                                    int flags, int share_mode,
1013                                    struct tevent_req **psmbreq)
1014 {
1015         struct tevent_req *req, *subreq;
1016         struct cli_open_state *state;
1017         unsigned openfn;
1018         unsigned accessmode;
1019         uint8_t additional_flags;
1020         uint8_t *bytes;
1021
1022         req = tevent_req_create(mem_ctx, &state, struct cli_open_state);
1023         if (req == NULL) {
1024                 return NULL;
1025         }
1026
1027         openfn = 0;
1028         if (flags & O_CREAT) {
1029                 openfn |= (1<<4);
1030         }
1031         if (!(flags & O_EXCL)) {
1032                 if (flags & O_TRUNC)
1033                         openfn |= (1<<1);
1034                 else
1035                         openfn |= (1<<0);
1036         }
1037
1038         accessmode = (share_mode<<4);
1039
1040         if ((flags & O_ACCMODE) == O_RDWR) {
1041                 accessmode |= 2;
1042         } else if ((flags & O_ACCMODE) == O_WRONLY) {
1043                 accessmode |= 1;
1044         }
1045
1046 #if defined(O_SYNC)
1047         if ((flags & O_SYNC) == O_SYNC) {
1048                 accessmode |= (1<<14);
1049         }
1050 #endif /* O_SYNC */
1051
1052         if (share_mode == DENY_FCB) {
1053                 accessmode = 0xFF;
1054         }
1055
1056         SCVAL(state->vwv + 0, 0, 0xFF);
1057         SCVAL(state->vwv + 0, 1, 0);
1058         SSVAL(state->vwv + 1, 0, 0);
1059         SSVAL(state->vwv + 2, 0, 0);  /* no additional info */
1060         SSVAL(state->vwv + 3, 0, accessmode);
1061         SSVAL(state->vwv + 4, 0, aSYSTEM | aHIDDEN);
1062         SSVAL(state->vwv + 5, 0, 0);
1063         SIVAL(state->vwv + 6, 0, 0);
1064         SSVAL(state->vwv + 8, 0, openfn);
1065         SIVAL(state->vwv + 9, 0, 0);
1066         SIVAL(state->vwv + 11, 0, 0);
1067         SIVAL(state->vwv + 13, 0, 0);
1068
1069         additional_flags = 0;
1070
1071         if (cli->use_oplocks) {
1072                 /* if using oplocks then ask for a batch oplock via
1073                    core and extended methods */
1074                 additional_flags =
1075                         FLAG_REQUEST_OPLOCK|FLAG_REQUEST_BATCH_OPLOCK;
1076                 SSVAL(state->vwv+2, 0, SVAL(state->vwv+2, 0) | 6);
1077         }
1078
1079         bytes = talloc_array(state, uint8_t, 0);
1080         bytes = smb_bytes_push_str(bytes, cli_ucs2(cli), fname,
1081                                    strlen(fname)+1, NULL);
1082
1083         if (tevent_req_nomem(bytes, req)) {
1084                 return tevent_req_post(req, ev);
1085         }
1086
1087         state->bytes.iov_base = bytes;
1088         state->bytes.iov_len = talloc_get_size(bytes);
1089
1090         subreq = cli_smb_req_create(state, ev, cli, SMBopenX, additional_flags,
1091                                     15, state->vwv, 1, &state->bytes);
1092         if (subreq == NULL) {
1093                 TALLOC_FREE(req);
1094                 return NULL;
1095         }
1096         tevent_req_set_callback(subreq, cli_open_done, req);
1097         *psmbreq = subreq;
1098         return req;
1099 }
1100
1101 struct tevent_req *cli_open_send(TALLOC_CTX *mem_ctx, struct event_context *ev,
1102                                  struct cli_state *cli, const char *fname,
1103                                  int flags, int share_mode)
1104 {
1105         struct tevent_req *req, *subreq;
1106
1107         req = cli_open_create(mem_ctx, ev, cli, fname, flags, share_mode,
1108                               &subreq);
1109         if ((req == NULL) || !cli_smb_req_send(subreq)) {
1110                 TALLOC_FREE(req);
1111                 return NULL;
1112         }
1113         return req;
1114 }
1115
1116 static void cli_open_done(struct tevent_req *subreq)
1117 {
1118         struct tevent_req *req = tevent_req_callback_data(
1119                 subreq, struct tevent_req);
1120         struct cli_open_state *state = tevent_req_data(
1121                 req, struct cli_open_state);
1122         uint8_t wct;
1123         uint16_t *vwv;
1124         NTSTATUS status;
1125
1126         status = cli_smb_recv(subreq, 3, &wct, &vwv, NULL, NULL);
1127         if (!NT_STATUS_IS_OK(status)) {
1128                 TALLOC_FREE(subreq);
1129                 tevent_req_nterror(req, status);
1130                 return;
1131         }
1132         state->fnum = SVAL(vwv+2, 0);
1133         tevent_req_done(req);
1134 }
1135
1136 NTSTATUS cli_open_recv(struct tevent_req *req, int *fnum)
1137 {
1138         struct cli_open_state *state = tevent_req_data(
1139                 req, struct cli_open_state);
1140         NTSTATUS status;
1141
1142         if (tevent_req_is_nterror(req, &status)) {
1143                 return status;
1144         }
1145         *fnum = state->fnum;
1146         return NT_STATUS_OK;
1147 }
1148
1149 int cli_open(struct cli_state *cli, const char *fname, int flags,
1150              int share_mode)
1151 {
1152         TALLOC_CTX *frame = talloc_stackframe();
1153         struct event_context *ev;
1154         struct tevent_req *req;
1155         NTSTATUS status = NT_STATUS_OK;
1156         int result = -1;
1157
1158         if (cli_has_async_calls(cli)) {
1159                 /*
1160                  * Can't use sync call while an async call is in flight
1161                  */
1162                 status = NT_STATUS_INVALID_PARAMETER;
1163                 goto fail;
1164         }
1165
1166         ev = event_context_init(frame);
1167         if (ev == NULL) {
1168                 status = NT_STATUS_NO_MEMORY;
1169                 goto fail;
1170         }
1171
1172         req = cli_open_send(frame, ev, cli, fname, flags, share_mode);
1173         if (req == NULL) {
1174                 status = NT_STATUS_NO_MEMORY;
1175                 goto fail;
1176         }
1177
1178         if (!tevent_req_poll(req, ev)) {
1179                 status = map_nt_error_from_unix(errno);
1180                 goto fail;
1181         }
1182
1183         cli_open_recv(req, &result);
1184  fail:
1185         TALLOC_FREE(frame);
1186         if (!NT_STATUS_IS_OK(status)) {
1187                 cli_set_error(cli, status);
1188         }
1189         return result;
1190 }
1191
1192 /****************************************************************************
1193  Close a file.
1194 ****************************************************************************/
1195
1196 struct cli_close_state {
1197         uint16_t vwv[3];
1198 };
1199
1200 static void cli_close_done(struct tevent_req *subreq);
1201
1202 struct tevent_req *cli_close_create(TALLOC_CTX *mem_ctx,
1203                                     struct event_context *ev,
1204                                     struct cli_state *cli, int fnum,
1205                                     struct tevent_req **psubreq)
1206 {
1207         struct tevent_req *req, *subreq;
1208         struct cli_close_state *state;
1209
1210         req = tevent_req_create(mem_ctx, &state, struct cli_close_state);
1211         if (req == NULL) {
1212                 return NULL;
1213         }
1214         SSVAL(state->vwv+0, 0, fnum);
1215         SIVALS(state->vwv+1, 0, -1);
1216
1217         subreq = cli_smb_req_create(state, ev, cli, SMBclose, 0, 3, state->vwv,
1218                                     0, NULL);
1219         if (subreq == NULL) {
1220                 TALLOC_FREE(req);
1221                 return NULL;
1222         }
1223         tevent_req_set_callback(subreq, cli_close_done, req);
1224         *psubreq = subreq;
1225         return req;
1226 }
1227
1228 struct tevent_req *cli_close_send(TALLOC_CTX *mem_ctx,
1229                                   struct event_context *ev,
1230                                   struct cli_state *cli, int fnum)
1231 {
1232         struct tevent_req *req, *subreq;
1233
1234         req = cli_close_create(mem_ctx, ev, cli, fnum, &subreq);
1235         if ((req == NULL) || !cli_smb_req_send(subreq)) {
1236                 TALLOC_FREE(req);
1237                 return NULL;
1238         }
1239         return req;
1240 }
1241
1242 static void cli_close_done(struct tevent_req *subreq)
1243 {
1244         struct tevent_req *req = tevent_req_callback_data(
1245                 subreq, struct tevent_req);
1246         NTSTATUS status;
1247
1248         status = cli_smb_recv(subreq, 0, NULL, NULL, NULL, NULL);
1249         TALLOC_FREE(subreq);
1250         if (!NT_STATUS_IS_OK(status)) {
1251                 tevent_req_nterror(req, status);
1252                 return;
1253         }
1254         tevent_req_done(req);
1255 }
1256
1257 NTSTATUS cli_close_recv(struct tevent_req *req)
1258 {
1259         return tevent_req_simple_recv_ntstatus(req);
1260 }
1261
1262 bool cli_close(struct cli_state *cli, int fnum)
1263 {
1264         TALLOC_CTX *frame = talloc_stackframe();
1265         struct event_context *ev;
1266         struct tevent_req *req;
1267         NTSTATUS status = NT_STATUS_OK;
1268         bool result = false;
1269
1270         if (cli_has_async_calls(cli)) {
1271                 /*
1272                  * Can't use sync call while an async call is in flight
1273                  */
1274                 status = NT_STATUS_INVALID_PARAMETER;
1275                 goto fail;
1276         }
1277
1278         ev = event_context_init(frame);
1279         if (ev == NULL) {
1280                 status = NT_STATUS_NO_MEMORY;
1281                 goto fail;
1282         }
1283
1284         req = cli_close_send(frame, ev, cli, fnum);
1285         if (req == NULL) {
1286                 status = NT_STATUS_NO_MEMORY;
1287                 goto fail;
1288         }
1289
1290         if (!tevent_req_poll(req, ev)) {
1291                 status = map_nt_error_from_unix(errno);
1292                 goto fail;
1293         }
1294
1295         result = NT_STATUS_IS_OK(cli_close_recv(req));
1296  fail:
1297         TALLOC_FREE(frame);
1298         if (!NT_STATUS_IS_OK(status)) {
1299                 cli_set_error(cli, status);
1300         }
1301         return result;
1302 }
1303
1304 /****************************************************************************
1305  Truncate a file to a specified size
1306 ****************************************************************************/
1307
1308 bool cli_ftruncate(struct cli_state *cli, int fnum, uint64_t size)
1309 {
1310         unsigned int param_len = 6;
1311         unsigned int data_len = 8;
1312         uint16 setup = TRANSACT2_SETFILEINFO;
1313         char param[6];
1314         unsigned char data[8];
1315         char *rparam=NULL, *rdata=NULL;
1316         int saved_timeout = cli->timeout;
1317
1318         SSVAL(param,0,fnum);
1319         SSVAL(param,2,SMB_SET_FILE_END_OF_FILE_INFO);
1320         SSVAL(param,4,0);
1321
1322         SBVAL(data, 0, size);
1323
1324         if (!cli_send_trans(cli, SMBtrans2,
1325                             NULL,                    /* name */
1326                             -1, 0,                   /* fid, flags */
1327                             &setup, 1, 0,            /* setup, length, max */
1328                             param, param_len, 2,     /* param, length, max */
1329                             (char *)&data,  data_len,/* data, length, ... */
1330                             cli->max_xmit)) {        /* ... max */
1331                 cli->timeout = saved_timeout;
1332                 return False;
1333         }
1334
1335         if (!cli_receive_trans(cli, SMBtrans2,
1336                                 &rparam, &param_len,
1337                                 &rdata, &data_len)) {
1338                 cli->timeout = saved_timeout;
1339                 SAFE_FREE(rdata);
1340                 SAFE_FREE(rparam);
1341                 return False;
1342         }
1343
1344         cli->timeout = saved_timeout;
1345
1346         SAFE_FREE(rdata);
1347         SAFE_FREE(rparam);
1348
1349         return True;
1350 }
1351
1352
1353 /****************************************************************************
1354  send a lock with a specified locktype
1355  this is used for testing LOCKING_ANDX_CANCEL_LOCK
1356 ****************************************************************************/
1357
1358 NTSTATUS cli_locktype(struct cli_state *cli, int fnum,
1359                       uint32 offset, uint32 len,
1360                       int timeout, unsigned char locktype)
1361 {
1362         char *p;
1363         int saved_timeout = cli->timeout;
1364
1365         memset(cli->outbuf,'\0',smb_size);
1366         memset(cli->inbuf,'\0', smb_size);
1367
1368         cli_set_message(cli->outbuf,8,0,True);
1369
1370         SCVAL(cli->outbuf,smb_com,SMBlockingX);
1371         SSVAL(cli->outbuf,smb_tid,cli->cnum);
1372         cli_setup_packet(cli);
1373
1374         SCVAL(cli->outbuf,smb_vwv0,0xFF);
1375         SSVAL(cli->outbuf,smb_vwv2,fnum);
1376         SCVAL(cli->outbuf,smb_vwv3,locktype);
1377         SIVALS(cli->outbuf, smb_vwv4, timeout);
1378         SSVAL(cli->outbuf,smb_vwv6,0);
1379         SSVAL(cli->outbuf,smb_vwv7,1);
1380
1381         p = smb_buf(cli->outbuf);
1382         SSVAL(p, 0, cli->pid);
1383         SIVAL(p, 2, offset);
1384         SIVAL(p, 6, len);
1385
1386         p += 10;
1387
1388         cli_setup_bcc(cli, p);
1389
1390         cli_send_smb(cli);
1391
1392         if (timeout != 0) {
1393                 cli->timeout = (timeout == -1) ? 0x7FFFFFFF : (timeout + 2*1000);
1394         }
1395
1396         if (!cli_receive_smb(cli)) {
1397                 cli->timeout = saved_timeout;
1398                 return NT_STATUS_UNSUCCESSFUL;
1399         }
1400
1401         cli->timeout = saved_timeout;
1402
1403         return cli_nt_error(cli);
1404 }
1405
1406 /****************************************************************************
1407  Lock a file.
1408  note that timeout is in units of 2 milliseconds
1409 ****************************************************************************/
1410
1411 bool cli_lock(struct cli_state *cli, int fnum,
1412               uint32 offset, uint32 len, int timeout, enum brl_type lock_type)
1413 {
1414         char *p;
1415         int saved_timeout = cli->timeout;
1416
1417         memset(cli->outbuf,'\0',smb_size);
1418         memset(cli->inbuf,'\0', smb_size);
1419
1420         cli_set_message(cli->outbuf,8,0,True);
1421
1422         SCVAL(cli->outbuf,smb_com,SMBlockingX);
1423         SSVAL(cli->outbuf,smb_tid,cli->cnum);
1424         cli_setup_packet(cli);
1425
1426         SCVAL(cli->outbuf,smb_vwv0,0xFF);
1427         SSVAL(cli->outbuf,smb_vwv2,fnum);
1428         SCVAL(cli->outbuf,smb_vwv3,(lock_type == READ_LOCK? 1 : 0));
1429         SIVALS(cli->outbuf, smb_vwv4, timeout);
1430         SSVAL(cli->outbuf,smb_vwv6,0);
1431         SSVAL(cli->outbuf,smb_vwv7,1);
1432
1433         p = smb_buf(cli->outbuf);
1434         SSVAL(p, 0, cli->pid);
1435         SIVAL(p, 2, offset);
1436         SIVAL(p, 6, len);
1437
1438         p += 10;
1439
1440         cli_setup_bcc(cli, p);
1441
1442         cli_send_smb(cli);
1443
1444         if (timeout != 0) {
1445                 cli->timeout = (timeout == -1) ? 0x7FFFFFFF : (timeout*2 + 5*1000);
1446         }
1447
1448         if (!cli_receive_smb(cli)) {
1449                 cli->timeout = saved_timeout;
1450                 return False;
1451         }
1452
1453         cli->timeout = saved_timeout;
1454
1455         if (cli_is_error(cli)) {
1456                 return False;
1457         }
1458
1459         return True;
1460 }
1461
1462 /****************************************************************************
1463  Unlock a file.
1464 ****************************************************************************/
1465
1466 bool cli_unlock(struct cli_state *cli, int fnum, uint32 offset, uint32 len)
1467 {
1468         char *p;
1469
1470         memset(cli->outbuf,'\0',smb_size);
1471         memset(cli->inbuf,'\0',smb_size);
1472
1473         cli_set_message(cli->outbuf,8,0,True);
1474
1475         SCVAL(cli->outbuf,smb_com,SMBlockingX);
1476         SSVAL(cli->outbuf,smb_tid,cli->cnum);
1477         cli_setup_packet(cli);
1478
1479         SCVAL(cli->outbuf,smb_vwv0,0xFF);
1480         SSVAL(cli->outbuf,smb_vwv2,fnum);
1481         SCVAL(cli->outbuf,smb_vwv3,0);
1482         SIVALS(cli->outbuf, smb_vwv4, 0);
1483         SSVAL(cli->outbuf,smb_vwv6,1);
1484         SSVAL(cli->outbuf,smb_vwv7,0);
1485
1486         p = smb_buf(cli->outbuf);
1487         SSVAL(p, 0, cli->pid);
1488         SIVAL(p, 2, offset);
1489         SIVAL(p, 6, len);
1490         p += 10;
1491         cli_setup_bcc(cli, p);
1492         cli_send_smb(cli);
1493         if (!cli_receive_smb(cli)) {
1494                 return False;
1495         }
1496
1497         if (cli_is_error(cli)) {
1498                 return False;
1499         }
1500
1501         return True;
1502 }
1503
1504 /****************************************************************************
1505  Lock a file with 64 bit offsets.
1506 ****************************************************************************/
1507
1508 bool cli_lock64(struct cli_state *cli, int fnum,
1509                 uint64_t offset, uint64_t len, int timeout, enum brl_type lock_type)
1510 {
1511         char *p;
1512         int saved_timeout = cli->timeout;
1513         int ltype;
1514
1515         if (! (cli->capabilities & CAP_LARGE_FILES)) {
1516                 return cli_lock(cli, fnum, offset, len, timeout, lock_type);
1517         }
1518
1519         ltype = (lock_type == READ_LOCK? 1 : 0);
1520         ltype |= LOCKING_ANDX_LARGE_FILES;
1521
1522         memset(cli->outbuf,'\0',smb_size);
1523         memset(cli->inbuf,'\0', smb_size);
1524
1525         cli_set_message(cli->outbuf,8,0,True);
1526
1527         SCVAL(cli->outbuf,smb_com,SMBlockingX);
1528         SSVAL(cli->outbuf,smb_tid,cli->cnum);
1529         cli_setup_packet(cli);
1530
1531         SCVAL(cli->outbuf,smb_vwv0,0xFF);
1532         SSVAL(cli->outbuf,smb_vwv2,fnum);
1533         SCVAL(cli->outbuf,smb_vwv3,ltype);
1534         SIVALS(cli->outbuf, smb_vwv4, timeout);
1535         SSVAL(cli->outbuf,smb_vwv6,0);
1536         SSVAL(cli->outbuf,smb_vwv7,1);
1537
1538         p = smb_buf(cli->outbuf);
1539         SIVAL(p, 0, cli->pid);
1540         SOFF_T_R(p, 4, offset);
1541         SOFF_T_R(p, 12, len);
1542         p += 20;
1543
1544         cli_setup_bcc(cli, p);
1545         cli_send_smb(cli);
1546
1547         if (timeout != 0) {
1548                 cli->timeout = (timeout == -1) ? 0x7FFFFFFF : (timeout + 5*1000);
1549         }
1550
1551         if (!cli_receive_smb(cli)) {
1552                 cli->timeout = saved_timeout;
1553                 return False;
1554         }
1555
1556         cli->timeout = saved_timeout;
1557
1558         if (cli_is_error(cli)) {
1559                 return False;
1560         }
1561
1562         return True;
1563 }
1564
1565 /****************************************************************************
1566  Unlock a file with 64 bit offsets.
1567 ****************************************************************************/
1568
1569 bool cli_unlock64(struct cli_state *cli, int fnum, uint64_t offset, uint64_t len)
1570 {
1571         char *p;
1572
1573         if (! (cli->capabilities & CAP_LARGE_FILES)) {
1574                 return cli_unlock(cli, fnum, offset, len);
1575         }
1576
1577         memset(cli->outbuf,'\0',smb_size);
1578         memset(cli->inbuf,'\0',smb_size);
1579
1580         cli_set_message(cli->outbuf,8,0,True);
1581
1582         SCVAL(cli->outbuf,smb_com,SMBlockingX);
1583         SSVAL(cli->outbuf,smb_tid,cli->cnum);
1584         cli_setup_packet(cli);
1585
1586         SCVAL(cli->outbuf,smb_vwv0,0xFF);
1587         SSVAL(cli->outbuf,smb_vwv2,fnum);
1588         SCVAL(cli->outbuf,smb_vwv3,LOCKING_ANDX_LARGE_FILES);
1589         SIVALS(cli->outbuf, smb_vwv4, 0);
1590         SSVAL(cli->outbuf,smb_vwv6,1);
1591         SSVAL(cli->outbuf,smb_vwv7,0);
1592
1593         p = smb_buf(cli->outbuf);
1594         SIVAL(p, 0, cli->pid);
1595         SOFF_T_R(p, 4, offset);
1596         SOFF_T_R(p, 12, len);
1597         p += 20;
1598         cli_setup_bcc(cli, p);
1599         cli_send_smb(cli);
1600         if (!cli_receive_smb(cli)) {
1601                 return False;
1602         }
1603
1604         if (cli_is_error(cli)) {
1605                 return False;
1606         }
1607
1608         return True;
1609 }
1610
1611 /****************************************************************************
1612  Get/unlock a POSIX lock on a file - internal function.
1613 ****************************************************************************/
1614
1615 static bool cli_posix_lock_internal(struct cli_state *cli, int fnum,
1616                 uint64_t offset, uint64_t len, bool wait_lock, enum brl_type lock_type)
1617 {
1618         unsigned int param_len = 4;
1619         unsigned int data_len = POSIX_LOCK_DATA_SIZE;
1620         uint16 setup = TRANSACT2_SETFILEINFO;
1621         char param[4];
1622         unsigned char data[POSIX_LOCK_DATA_SIZE];
1623         char *rparam=NULL, *rdata=NULL;
1624         int saved_timeout = cli->timeout;
1625
1626         SSVAL(param,0,fnum);
1627         SSVAL(param,2,SMB_SET_POSIX_LOCK);
1628
1629         switch (lock_type) {
1630                 case READ_LOCK:
1631                         SSVAL(data, POSIX_LOCK_TYPE_OFFSET, POSIX_LOCK_TYPE_READ);
1632                         break;
1633                 case WRITE_LOCK:
1634                         SSVAL(data, POSIX_LOCK_TYPE_OFFSET, POSIX_LOCK_TYPE_WRITE);
1635                         break;
1636                 case UNLOCK_LOCK:
1637                         SSVAL(data, POSIX_LOCK_TYPE_OFFSET, POSIX_LOCK_TYPE_UNLOCK);
1638                         break;
1639                 default:
1640                         return False;
1641         }
1642
1643         if (wait_lock) {
1644                 SSVAL(data, POSIX_LOCK_FLAGS_OFFSET, POSIX_LOCK_FLAG_WAIT);
1645                 cli->timeout = 0x7FFFFFFF;
1646         } else {
1647                 SSVAL(data, POSIX_LOCK_FLAGS_OFFSET, POSIX_LOCK_FLAG_NOWAIT);
1648         }
1649
1650         SIVAL(data, POSIX_LOCK_PID_OFFSET, cli->pid);
1651         SOFF_T(data, POSIX_LOCK_START_OFFSET, offset);
1652         SOFF_T(data, POSIX_LOCK_LEN_OFFSET, len);
1653
1654         if (!cli_send_trans(cli, SMBtrans2,
1655                         NULL,                        /* name */
1656                         -1, 0,                          /* fid, flags */
1657                         &setup, 1, 0,                   /* setup, length, max */
1658                         param, param_len, 2,            /* param, length, max */
1659                         (char *)&data,  data_len, cli->max_xmit /* data, length, max */
1660                         )) {
1661                 cli->timeout = saved_timeout;
1662                 return False;
1663         }
1664
1665         if (!cli_receive_trans(cli, SMBtrans2,
1666                                 &rparam, &param_len,
1667                                 &rdata, &data_len)) {
1668                 cli->timeout = saved_timeout;
1669                 SAFE_FREE(rdata);
1670                 SAFE_FREE(rparam);
1671                 return False;
1672         }
1673
1674         cli->timeout = saved_timeout;
1675
1676         SAFE_FREE(rdata);
1677         SAFE_FREE(rparam);
1678
1679         return True;
1680 }
1681
1682 /****************************************************************************
1683  POSIX Lock a file.
1684 ****************************************************************************/
1685
1686 bool cli_posix_lock(struct cli_state *cli, int fnum,
1687                         uint64_t offset, uint64_t len,
1688                         bool wait_lock, enum brl_type lock_type)
1689 {
1690         if (lock_type != READ_LOCK && lock_type != WRITE_LOCK) {
1691                 return False;
1692         }
1693         return cli_posix_lock_internal(cli, fnum, offset, len, wait_lock, lock_type);
1694 }
1695
1696 /****************************************************************************
1697  POSIX Unlock a file.
1698 ****************************************************************************/
1699
1700 bool cli_posix_unlock(struct cli_state *cli, int fnum, uint64_t offset, uint64_t len)
1701 {
1702         return cli_posix_lock_internal(cli, fnum, offset, len, False, UNLOCK_LOCK);
1703 }
1704
1705 /****************************************************************************
1706  POSIX Get any lock covering a file.
1707 ****************************************************************************/
1708
1709 bool cli_posix_getlock(struct cli_state *cli, int fnum, uint64_t *poffset, uint64_t *plen)
1710 {
1711         return True;
1712 }
1713
1714 /****************************************************************************
1715  Do a SMBgetattrE call.
1716 ****************************************************************************/
1717
1718 bool cli_getattrE(struct cli_state *cli, int fd,
1719                   uint16 *attr, SMB_OFF_T *size,
1720                   time_t *change_time,
1721                   time_t *access_time,
1722                   time_t *write_time)
1723 {
1724         memset(cli->outbuf,'\0',smb_size);
1725         memset(cli->inbuf,'\0',smb_size);
1726
1727         cli_set_message(cli->outbuf,1,0,True);
1728
1729         SCVAL(cli->outbuf,smb_com,SMBgetattrE);
1730         SSVAL(cli->outbuf,smb_tid,cli->cnum);
1731         cli_setup_packet(cli);
1732
1733         SSVAL(cli->outbuf,smb_vwv0,fd);
1734
1735         cli_send_smb(cli);
1736         if (!cli_receive_smb(cli)) {
1737                 return False;
1738         }
1739
1740         if (cli_is_error(cli)) {
1741                 return False;
1742         }
1743
1744         if (size) {
1745                 *size = IVAL(cli->inbuf, smb_vwv6);
1746         }
1747
1748         if (attr) {
1749                 *attr = SVAL(cli->inbuf,smb_vwv10);
1750         }
1751
1752         if (change_time) {
1753                 *change_time = cli_make_unix_date2(cli, cli->inbuf+smb_vwv0);
1754         }
1755
1756         if (access_time) {
1757                 *access_time = cli_make_unix_date2(cli, cli->inbuf+smb_vwv2);
1758         }
1759
1760         if (write_time) {
1761                 *write_time = cli_make_unix_date2(cli, cli->inbuf+smb_vwv4);
1762         }
1763
1764         return True;
1765 }
1766
1767 /****************************************************************************
1768  Do a SMBgetatr call
1769 ****************************************************************************/
1770
1771 bool cli_getatr(struct cli_state *cli, const char *fname,
1772                 uint16 *attr, SMB_OFF_T *size, time_t *write_time)
1773 {
1774         char *p;
1775
1776         memset(cli->outbuf,'\0',smb_size);
1777         memset(cli->inbuf,'\0',smb_size);
1778
1779         cli_set_message(cli->outbuf,0,0,True);
1780
1781         SCVAL(cli->outbuf,smb_com,SMBgetatr);
1782         SSVAL(cli->outbuf,smb_tid,cli->cnum);
1783         cli_setup_packet(cli);
1784
1785         p = smb_buf(cli->outbuf);
1786         *p++ = 4;
1787         p += clistr_push(cli, p, fname,
1788                         cli->bufsize - PTR_DIFF(p,cli->outbuf), STR_TERMINATE);
1789
1790         cli_setup_bcc(cli, p);
1791
1792         cli_send_smb(cli);
1793         if (!cli_receive_smb(cli)) {
1794                 return False;
1795         }
1796
1797         if (cli_is_error(cli)) {
1798                 return False;
1799         }
1800
1801         if (size) {
1802                 *size = IVAL(cli->inbuf, smb_vwv3);
1803         }
1804
1805         if (write_time) {
1806                 *write_time = cli_make_unix_date3(cli, cli->inbuf+smb_vwv1);
1807         }
1808
1809         if (attr) {
1810                 *attr = SVAL(cli->inbuf,smb_vwv0);
1811         }
1812
1813         return True;
1814 }
1815
1816 /****************************************************************************
1817  Do a SMBsetattrE call.
1818 ****************************************************************************/
1819
1820 bool cli_setattrE(struct cli_state *cli, int fd,
1821                   time_t change_time,
1822                   time_t access_time,
1823                   time_t write_time)
1824
1825 {
1826         char *p;
1827
1828         memset(cli->outbuf,'\0',smb_size);
1829         memset(cli->inbuf,'\0',smb_size);
1830
1831         cli_set_message(cli->outbuf,7,0,True);
1832
1833         SCVAL(cli->outbuf,smb_com,SMBsetattrE);
1834         SSVAL(cli->outbuf,smb_tid,cli->cnum);
1835         cli_setup_packet(cli);
1836
1837         SSVAL(cli->outbuf,smb_vwv0, fd);
1838         cli_put_dos_date2(cli, cli->outbuf,smb_vwv1, change_time);
1839         cli_put_dos_date2(cli, cli->outbuf,smb_vwv3, access_time);
1840         cli_put_dos_date2(cli, cli->outbuf,smb_vwv5, write_time);
1841
1842         p = smb_buf(cli->outbuf);
1843         *p++ = 4;
1844
1845         cli_setup_bcc(cli, p);
1846
1847         cli_send_smb(cli);
1848         if (!cli_receive_smb(cli)) {
1849                 return False;
1850         }
1851
1852         if (cli_is_error(cli)) {
1853                 return False;
1854         }
1855
1856         return True;
1857 }
1858
1859 /****************************************************************************
1860  Do a SMBsetatr call.
1861 ****************************************************************************/
1862
1863 bool cli_setatr(struct cli_state *cli, const char *fname, uint16 attr, time_t t)
1864 {
1865         char *p;
1866
1867         memset(cli->outbuf,'\0',smb_size);
1868         memset(cli->inbuf,'\0',smb_size);
1869
1870         cli_set_message(cli->outbuf,8,0,True);
1871
1872         SCVAL(cli->outbuf,smb_com,SMBsetatr);
1873         SSVAL(cli->outbuf,smb_tid,cli->cnum);
1874         cli_setup_packet(cli);
1875
1876         SSVAL(cli->outbuf,smb_vwv0, attr);
1877         cli_put_dos_date3(cli, cli->outbuf,smb_vwv1, t);
1878
1879         p = smb_buf(cli->outbuf);
1880         *p++ = 4;
1881         p += clistr_push(cli, p, fname,
1882                         cli->bufsize - PTR_DIFF(p,cli->outbuf), STR_TERMINATE);
1883         *p++ = 4;
1884
1885         cli_setup_bcc(cli, p);
1886
1887         cli_send_smb(cli);
1888         if (!cli_receive_smb(cli)) {
1889                 return False;
1890         }
1891
1892         if (cli_is_error(cli)) {
1893                 return False;
1894         }
1895
1896         return True;
1897 }
1898
1899 /****************************************************************************
1900  Check for existance of a dir.
1901 ****************************************************************************/
1902
1903 bool cli_chkpath(struct cli_state *cli, const char *path)
1904 {
1905         char *path2 = NULL;
1906         char *p;
1907         TALLOC_CTX *frame = talloc_stackframe();
1908
1909         path2 = talloc_strdup(frame, path);
1910         if (!path2) {
1911                 TALLOC_FREE(frame);
1912                 return false;
1913         }
1914         trim_char(path2,'\0','\\');
1915         if (!*path2) {
1916                 path2 = talloc_strdup(frame, "\\");
1917                 if (!path2) {
1918                         TALLOC_FREE(frame);
1919                         return false;
1920                 }
1921         }
1922
1923         memset(cli->outbuf,'\0',smb_size);
1924         cli_set_message(cli->outbuf,0,0,True);
1925         SCVAL(cli->outbuf,smb_com,SMBcheckpath);
1926         SSVAL(cli->outbuf,smb_tid,cli->cnum);
1927         cli_setup_packet(cli);
1928         p = smb_buf(cli->outbuf);
1929         *p++ = 4;
1930         p += clistr_push(cli, p, path2,
1931                         cli->bufsize - PTR_DIFF(p,cli->outbuf), STR_TERMINATE);
1932
1933         cli_setup_bcc(cli, p);
1934
1935         cli_send_smb(cli);
1936         if (!cli_receive_smb(cli)) {
1937                 TALLOC_FREE(frame);
1938                 return False;
1939         }
1940
1941         TALLOC_FREE(frame);
1942
1943         if (cli_is_error(cli)) return False;
1944
1945         return True;
1946 }
1947
1948 /****************************************************************************
1949  Query disk space.
1950 ****************************************************************************/
1951
1952 bool cli_dskattr(struct cli_state *cli, int *bsize, int *total, int *avail)
1953 {
1954         memset(cli->outbuf,'\0',smb_size);
1955         cli_set_message(cli->outbuf,0,0,True);
1956         SCVAL(cli->outbuf,smb_com,SMBdskattr);
1957         SSVAL(cli->outbuf,smb_tid,cli->cnum);
1958         cli_setup_packet(cli);
1959
1960         cli_send_smb(cli);
1961         if (!cli_receive_smb(cli)) {
1962                 return False;
1963         }
1964
1965         *bsize = SVAL(cli->inbuf,smb_vwv1)*SVAL(cli->inbuf,smb_vwv2);
1966         *total = SVAL(cli->inbuf,smb_vwv0);
1967         *avail = SVAL(cli->inbuf,smb_vwv3);
1968
1969         return True;
1970 }
1971
1972 /****************************************************************************
1973  Create and open a temporary file.
1974 ****************************************************************************/
1975
1976 int cli_ctemp(struct cli_state *cli, const char *path, char **tmp_path)
1977 {
1978         int len;
1979         char *p;
1980
1981         memset(cli->outbuf,'\0',smb_size);
1982         memset(cli->inbuf,'\0',smb_size);
1983
1984         cli_set_message(cli->outbuf,3,0,True);
1985
1986         SCVAL(cli->outbuf,smb_com,SMBctemp);
1987         SSVAL(cli->outbuf,smb_tid,cli->cnum);
1988         cli_setup_packet(cli);
1989
1990         SSVAL(cli->outbuf,smb_vwv0,0);
1991         SIVALS(cli->outbuf,smb_vwv1,-1);
1992
1993         p = smb_buf(cli->outbuf);
1994         *p++ = 4;
1995         p += clistr_push(cli, p, path,
1996                         cli->bufsize - PTR_DIFF(p,cli->outbuf), STR_TERMINATE);
1997
1998         cli_setup_bcc(cli, p);
1999
2000         cli_send_smb(cli);
2001         if (!cli_receive_smb(cli)) {
2002                 return -1;
2003         }
2004
2005         if (cli_is_error(cli)) {
2006                 return -1;
2007         }
2008
2009         /* despite the spec, the result has a -1, followed by
2010            length, followed by name */
2011         p = smb_buf(cli->inbuf);
2012         p += 4;
2013         len = smb_buflen(cli->inbuf) - 4;
2014         if (len <= 0 || len > PATH_MAX) return -1;
2015
2016         if (tmp_path) {
2017                 char *path2 = SMB_MALLOC_ARRAY(char, len+1);
2018                 if (!path2) {
2019                         return -1;
2020                 }
2021                 clistr_pull(cli->inbuf, path2, p,
2022                             len+1, len, STR_ASCII);
2023                 *tmp_path = path2;
2024         }
2025
2026         return SVAL(cli->inbuf,smb_vwv0);
2027 }
2028
2029 /*
2030    send a raw ioctl - used by the torture code
2031 */
2032 NTSTATUS cli_raw_ioctl(struct cli_state *cli, int fnum, uint32 code, DATA_BLOB *blob)
2033 {
2034         memset(cli->outbuf,'\0',smb_size);
2035         memset(cli->inbuf,'\0',smb_size);
2036
2037         cli_set_message(cli->outbuf, 3, 0, True);
2038         SCVAL(cli->outbuf,smb_com,SMBioctl);
2039         cli_setup_packet(cli);
2040
2041         SSVAL(cli->outbuf, smb_vwv0, fnum);
2042         SSVAL(cli->outbuf, smb_vwv1, code>>16);
2043         SSVAL(cli->outbuf, smb_vwv2, (code&0xFFFF));
2044
2045         cli_send_smb(cli);
2046         if (!cli_receive_smb(cli)) {
2047                 return NT_STATUS_UNEXPECTED_NETWORK_ERROR;
2048         }
2049
2050         if (cli_is_error(cli)) {
2051                 return cli_nt_error(cli);
2052         }
2053
2054         *blob = data_blob_null;
2055
2056         return NT_STATUS_OK;
2057 }
2058
2059 /*********************************************************
2060  Set an extended attribute utility fn.
2061 *********************************************************/
2062
2063 static bool cli_set_ea(struct cli_state *cli, uint16 setup, char *param, unsigned int param_len,
2064                         const char *ea_name, const char *ea_val, size_t ea_len)
2065 {
2066         unsigned int data_len = 0;
2067         char *data = NULL;
2068         char *rparam=NULL, *rdata=NULL;
2069         char *p;
2070         size_t ea_namelen = strlen(ea_name);
2071
2072         if (ea_namelen == 0 && ea_len == 0) {
2073                 data_len = 4;
2074                 data = (char *)SMB_MALLOC(data_len);
2075                 if (!data) {
2076                         return False;
2077                 }
2078                 p = data;
2079                 SIVAL(p,0,data_len);
2080         } else {
2081                 data_len = 4 + 4 + ea_namelen + 1 + ea_len;
2082                 data = (char *)SMB_MALLOC(data_len);
2083                 if (!data) {
2084                         return False;
2085                 }
2086                 p = data;
2087                 SIVAL(p,0,data_len);
2088                 p += 4;
2089                 SCVAL(p, 0, 0); /* EA flags. */
2090                 SCVAL(p, 1, ea_namelen);
2091                 SSVAL(p, 2, ea_len);
2092                 memcpy(p+4, ea_name, ea_namelen+1); /* Copy in the name. */
2093                 memcpy(p+4+ea_namelen+1, ea_val, ea_len);
2094         }
2095
2096         if (!cli_send_trans(cli, SMBtrans2,
2097                         NULL,                        /* name */
2098                         -1, 0,                          /* fid, flags */
2099                         &setup, 1, 0,                   /* setup, length, max */
2100                         param, param_len, 2,            /* param, length, max */
2101                         data,  data_len, cli->max_xmit /* data, length, max */
2102                         )) {
2103                 SAFE_FREE(data);
2104                 return False;
2105         }
2106
2107         if (!cli_receive_trans(cli, SMBtrans2,
2108                         &rparam, &param_len,
2109                         &rdata, &data_len)) {
2110                         SAFE_FREE(data);
2111                 return false;
2112         }
2113
2114         SAFE_FREE(data);
2115         SAFE_FREE(rdata);
2116         SAFE_FREE(rparam);
2117
2118         return True;
2119 }
2120
2121 /*********************************************************
2122  Set an extended attribute on a pathname.
2123 *********************************************************/
2124
2125 bool cli_set_ea_path(struct cli_state *cli, const char *path, const char *ea_name, const char *ea_val, size_t ea_len)
2126 {
2127         uint16 setup = TRANSACT2_SETPATHINFO;
2128         unsigned int param_len = 0;
2129         char *param;
2130         size_t srclen = 2*(strlen(path)+1);
2131         char *p;
2132         bool ret;
2133
2134         param = SMB_MALLOC_ARRAY(char, 6+srclen+2);
2135         if (!param) {
2136                 return false;
2137         }
2138         memset(param, '\0', 6);
2139         SSVAL(param,0,SMB_INFO_SET_EA);
2140         p = &param[6];
2141
2142         p += clistr_push(cli, p, path, srclen, STR_TERMINATE);
2143         param_len = PTR_DIFF(p, param);
2144
2145         ret = cli_set_ea(cli, setup, param, param_len, ea_name, ea_val, ea_len);
2146         SAFE_FREE(param);
2147         return ret;
2148 }
2149
2150 /*********************************************************
2151  Set an extended attribute on an fnum.
2152 *********************************************************/
2153
2154 bool cli_set_ea_fnum(struct cli_state *cli, int fnum, const char *ea_name, const char *ea_val, size_t ea_len)
2155 {
2156         char param[6];
2157         uint16 setup = TRANSACT2_SETFILEINFO;
2158
2159         memset(param, 0, 6);
2160         SSVAL(param,0,fnum);
2161         SSVAL(param,2,SMB_INFO_SET_EA);
2162
2163         return cli_set_ea(cli, setup, param, 6, ea_name, ea_val, ea_len);
2164 }
2165
2166 /*********************************************************
2167  Get an extended attribute list utility fn.
2168 *********************************************************/
2169
2170 static bool cli_get_ea_list(struct cli_state *cli,
2171                 uint16 setup, char *param, unsigned int param_len,
2172                 TALLOC_CTX *ctx,
2173                 size_t *pnum_eas,
2174                 struct ea_struct **pea_list)
2175 {
2176         unsigned int data_len = 0;
2177         unsigned int rparam_len, rdata_len;
2178         char *rparam=NULL, *rdata=NULL;
2179         char *p;
2180         size_t ea_size;
2181         size_t num_eas;
2182         bool ret = False;
2183         struct ea_struct *ea_list;
2184
2185         *pnum_eas = 0;
2186         if (pea_list) {
2187                 *pea_list = NULL;
2188         }
2189
2190         if (!cli_send_trans(cli, SMBtrans2,
2191                         NULL,           /* Name */
2192                         -1, 0,          /* fid, flags */
2193                         &setup, 1, 0,   /* setup, length, max */
2194                         param, param_len, 10, /* param, length, max */
2195                         NULL, data_len, cli->max_xmit /* data, length, max */
2196                                 )) {
2197                 return False;
2198         }
2199
2200         if (!cli_receive_trans(cli, SMBtrans2,
2201                         &rparam, &rparam_len,
2202                         &rdata, &rdata_len)) {
2203                 return False;
2204         }
2205
2206         if (!rdata || rdata_len < 4) {
2207                 goto out;
2208         }
2209
2210         ea_size = (size_t)IVAL(rdata,0);
2211         if (ea_size > rdata_len) {
2212                 goto out;
2213         }
2214
2215         if (ea_size == 0) {
2216                 /* No EA's present. */
2217                 ret = True;
2218                 goto out;
2219         }
2220
2221         p = rdata + 4;
2222         ea_size -= 4;
2223
2224         /* Validate the EA list and count it. */
2225         for (num_eas = 0; ea_size >= 4; num_eas++) {
2226                 unsigned int ea_namelen = CVAL(p,1);
2227                 unsigned int ea_valuelen = SVAL(p,2);
2228                 if (ea_namelen == 0) {
2229                         goto out;
2230                 }
2231                 if (4 + ea_namelen + 1 + ea_valuelen > ea_size) {
2232                         goto out;
2233                 }
2234                 ea_size -= 4 + ea_namelen + 1 + ea_valuelen;
2235                 p += 4 + ea_namelen + 1 + ea_valuelen;
2236         }
2237
2238         if (num_eas == 0) {
2239                 ret = True;
2240                 goto out;
2241         }
2242
2243         *pnum_eas = num_eas;
2244         if (!pea_list) {
2245                 /* Caller only wants number of EA's. */
2246                 ret = True;
2247                 goto out;
2248         }
2249
2250         ea_list = TALLOC_ARRAY(ctx, struct ea_struct, num_eas);
2251         if (!ea_list) {
2252                 goto out;
2253         }
2254
2255         ea_size = (size_t)IVAL(rdata,0);
2256         p = rdata + 4;
2257
2258         for (num_eas = 0; num_eas < *pnum_eas; num_eas++ ) {
2259                 struct ea_struct *ea = &ea_list[num_eas];
2260                 fstring unix_ea_name;
2261                 unsigned int ea_namelen = CVAL(p,1);
2262                 unsigned int ea_valuelen = SVAL(p,2);
2263
2264                 ea->flags = CVAL(p,0);
2265                 unix_ea_name[0] = '\0';
2266                 pull_ascii_fstring(unix_ea_name, p + 4);
2267                 ea->name = talloc_strdup(ctx, unix_ea_name);
2268                 /* Ensure the value is null terminated (in case it's a string). */
2269                 ea->value = data_blob_talloc(ctx, NULL, ea_valuelen + 1);
2270                 if (!ea->value.data) {
2271                         goto out;
2272                 }
2273                 if (ea_valuelen) {
2274                         memcpy(ea->value.data, p+4+ea_namelen+1, ea_valuelen);
2275                 }
2276                 ea->value.data[ea_valuelen] = 0;
2277                 ea->value.length--;
2278                 p += 4 + ea_namelen + 1 + ea_valuelen;
2279         }
2280
2281         *pea_list = ea_list;
2282         ret = True;
2283
2284  out :
2285
2286         SAFE_FREE(rdata);
2287         SAFE_FREE(rparam);
2288         return ret;
2289 }
2290
2291 /*********************************************************
2292  Get an extended attribute list from a pathname.
2293 *********************************************************/
2294
2295 bool cli_get_ea_list_path(struct cli_state *cli, const char *path,
2296                 TALLOC_CTX *ctx,
2297                 size_t *pnum_eas,
2298                 struct ea_struct **pea_list)
2299 {
2300         uint16 setup = TRANSACT2_QPATHINFO;
2301         unsigned int param_len = 0;
2302         char *param;
2303         char *p;
2304         size_t srclen = 2*(strlen(path)+1);
2305         bool ret;
2306
2307         param = SMB_MALLOC_ARRAY(char, 6+srclen+2);
2308         if (!param) {
2309                 return false;
2310         }
2311         p = param;
2312         memset(p, 0, 6);
2313         SSVAL(p, 0, SMB_INFO_QUERY_ALL_EAS);
2314         p += 6;
2315         p += clistr_push(cli, p, path, srclen, STR_TERMINATE);
2316         param_len = PTR_DIFF(p, param);
2317
2318         ret = cli_get_ea_list(cli, setup, param, param_len, ctx, pnum_eas, pea_list);
2319         SAFE_FREE(param);
2320         return ret;
2321 }
2322
2323 /*********************************************************
2324  Get an extended attribute list from an fnum.
2325 *********************************************************/
2326
2327 bool cli_get_ea_list_fnum(struct cli_state *cli, int fnum,
2328                 TALLOC_CTX *ctx,
2329                 size_t *pnum_eas,
2330                 struct ea_struct **pea_list)
2331 {
2332         uint16 setup = TRANSACT2_QFILEINFO;
2333         char param[6];
2334
2335         memset(param, 0, 6);
2336         SSVAL(param,0,fnum);
2337         SSVAL(param,2,SMB_INFO_SET_EA);
2338
2339         return cli_get_ea_list(cli, setup, param, 6, ctx, pnum_eas, pea_list);
2340 }
2341
2342 /****************************************************************************
2343  Convert open "flags" arg to uint32 on wire.
2344 ****************************************************************************/
2345
2346 static uint32 open_flags_to_wire(int flags)
2347 {
2348         int open_mode = flags & O_ACCMODE;
2349         uint32 ret = 0;
2350
2351         switch (open_mode) {
2352                 case O_WRONLY:
2353                         ret |= SMB_O_WRONLY;
2354                         break;
2355                 case O_RDWR:
2356                         ret |= SMB_O_RDWR;
2357                         break;
2358                 default:
2359                 case O_RDONLY:
2360                         ret |= SMB_O_RDONLY;
2361                         break;
2362         }
2363
2364         if (flags & O_CREAT) {
2365                 ret |= SMB_O_CREAT;
2366         }
2367         if (flags & O_EXCL) {
2368                 ret |= SMB_O_EXCL;
2369         }
2370         if (flags & O_TRUNC) {
2371                 ret |= SMB_O_TRUNC;
2372         }
2373 #if defined(O_SYNC)
2374         if (flags & O_SYNC) {
2375                 ret |= SMB_O_SYNC;
2376         }
2377 #endif /* O_SYNC */
2378         if (flags & O_APPEND) {
2379                 ret |= SMB_O_APPEND;
2380         }
2381 #if defined(O_DIRECT)
2382         if (flags & O_DIRECT) {
2383                 ret |= SMB_O_DIRECT;
2384         }
2385 #endif
2386 #if defined(O_DIRECTORY)
2387         if (flags & O_DIRECTORY) {
2388                 ret &= ~(SMB_O_RDONLY|SMB_O_RDWR|SMB_O_WRONLY);
2389                 ret |= SMB_O_DIRECTORY;
2390         }
2391 #endif
2392         return ret;
2393 }
2394
2395 /****************************************************************************
2396  Open a file - POSIX semantics. Returns fnum. Doesn't request oplock.
2397 ****************************************************************************/
2398
2399 static int cli_posix_open_internal(struct cli_state *cli, const char *fname, int flags, mode_t mode, bool is_dir)
2400 {
2401         unsigned int data_len = 0;
2402         unsigned int param_len = 0;
2403         uint16 setup = TRANSACT2_SETPATHINFO;
2404         char *param;
2405         char data[18];
2406         char *rparam=NULL, *rdata=NULL;
2407         char *p;
2408         int fnum = -1;
2409         uint32 wire_flags = open_flags_to_wire(flags);
2410         size_t srclen = 2*(strlen(fname)+1);
2411
2412         param = SMB_MALLOC_ARRAY(char, 6+srclen+2);
2413         if (!param) {
2414                 return false;
2415         }
2416         memset(param, '\0', 6);
2417         SSVAL(param,0, SMB_POSIX_PATH_OPEN);
2418         p = &param[6];
2419
2420         p += clistr_push(cli, p, fname, srclen, STR_TERMINATE);
2421         param_len = PTR_DIFF(p, param);
2422
2423         if (is_dir) {
2424                 wire_flags &= ~(SMB_O_RDONLY|SMB_O_RDWR|SMB_O_WRONLY);
2425                 wire_flags |= SMB_O_DIRECTORY;
2426         }
2427
2428         p = data;
2429         SIVAL(p,0,0); /* No oplock. */
2430         SIVAL(p,4,wire_flags);
2431         SIVAL(p,8,unix_perms_to_wire(mode));
2432         SIVAL(p,12,0); /* Top bits of perms currently undefined. */
2433         SSVAL(p,16,SMB_NO_INFO_LEVEL_RETURNED); /* No info level returned. */
2434
2435         data_len = 18;
2436
2437         if (!cli_send_trans(cli, SMBtrans2,
2438                         NULL,                        /* name */
2439                         -1, 0,                          /* fid, flags */
2440                         &setup, 1, 0,                   /* setup, length, max */
2441                         param, param_len, 2,            /* param, length, max */
2442                         (char *)&data,  data_len, cli->max_xmit /* data, length, max */
2443                         )) {
2444                 SAFE_FREE(param);
2445                 return -1;
2446         }
2447
2448         SAFE_FREE(param);
2449
2450         if (!cli_receive_trans(cli, SMBtrans2,
2451                 &rparam, &param_len,
2452                 &rdata, &data_len)) {
2453                         return -1;
2454         }
2455
2456         fnum = SVAL(rdata,2);
2457
2458         SAFE_FREE(rdata);
2459         SAFE_FREE(rparam);
2460
2461         return fnum;
2462 }
2463
2464 /****************************************************************************
2465  open - POSIX semantics.
2466 ****************************************************************************/
2467
2468 int cli_posix_open(struct cli_state *cli, const char *fname, int flags, mode_t mode)
2469 {
2470         return cli_posix_open_internal(cli, fname, flags, mode, False);
2471 }
2472
2473 /****************************************************************************
2474  mkdir - POSIX semantics.
2475 ****************************************************************************/
2476
2477 int cli_posix_mkdir(struct cli_state *cli, const char *fname, mode_t mode)
2478 {
2479         return (cli_posix_open_internal(cli, fname, O_CREAT, mode, True) == -1) ? -1 : 0;
2480 }
2481
2482 /****************************************************************************
2483  unlink or rmdir - POSIX semantics.
2484 ****************************************************************************/
2485
2486 static bool cli_posix_unlink_internal(struct cli_state *cli, const char *fname, bool is_dir)
2487 {
2488         unsigned int data_len = 0;
2489         unsigned int param_len = 0;
2490         uint16 setup = TRANSACT2_SETPATHINFO;
2491         char *param;
2492         char data[2];
2493         char *rparam=NULL, *rdata=NULL;
2494         char *p;
2495         size_t srclen = 2*(strlen(fname)+1);
2496
2497         param = SMB_MALLOC_ARRAY(char, 6+srclen+2);
2498         if (!param) {
2499                 return false;
2500         }
2501         memset(param, '\0', 6);
2502         SSVAL(param,0, SMB_POSIX_PATH_UNLINK);
2503         p = &param[6];
2504
2505         p += clistr_push(cli, p, fname, srclen, STR_TERMINATE);
2506         param_len = PTR_DIFF(p, param);
2507
2508         SSVAL(data, 0, is_dir ? SMB_POSIX_UNLINK_DIRECTORY_TARGET :
2509                         SMB_POSIX_UNLINK_FILE_TARGET);
2510         data_len = 2;
2511
2512         if (!cli_send_trans(cli, SMBtrans2,
2513                         NULL,                        /* name */
2514                         -1, 0,                          /* fid, flags */
2515                         &setup, 1, 0,                   /* setup, length, max */
2516                         param, param_len, 2,            /* param, length, max */
2517                         (char *)&data,  data_len, cli->max_xmit /* data, length, max */
2518                         )) {
2519                 SAFE_FREE(param);
2520                 return False;
2521         }
2522
2523         SAFE_FREE(param);
2524
2525         if (!cli_receive_trans(cli, SMBtrans2,
2526                 &rparam, &param_len,
2527                 &rdata, &data_len)) {
2528                         return False;
2529         }
2530
2531         SAFE_FREE(rdata);
2532         SAFE_FREE(rparam);
2533
2534         return True;
2535 }
2536
2537 /****************************************************************************
2538  unlink - POSIX semantics.
2539 ****************************************************************************/
2540
2541 bool cli_posix_unlink(struct cli_state *cli, const char *fname)
2542 {
2543         return cli_posix_unlink_internal(cli, fname, False);
2544 }
2545
2546 /****************************************************************************
2547  rmdir - POSIX semantics.
2548 ****************************************************************************/
2549
2550 int cli_posix_rmdir(struct cli_state *cli, const char *fname)
2551 {
2552         return cli_posix_unlink_internal(cli, fname, True);
2553 }