source/libsmb/clifile.c

   1 /*
   2    Unix SMB/Netbios implementation.
   3    Version 3.0
   4    client file operations
   5    Copyright (C) Andrew Tridgell 1994-1998
   6    Copyright (C) Jeremy Allison 2001-2002
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21 */
  22
  23 #define NO_SYSLOG
  24
  25 #include "includes.h"
  26
  27 /****************************************************************************
  28  Hard/Symlink a file (UNIX extensions).
  29 ****************************************************************************/
  30
  31 static BOOL cli_link_internal(struct cli_state *cli, const char *fname_src, const char *fname_dst, BOOL hard_link)
  32 {
  33         int data_len = 0;
  34         int param_len = 0;
  35         uint16 setup = TRANSACT2_SETPATHINFO;
  36         char param[sizeof(pstring)+6];
  37         pstring data;
  38         char *rparam=NULL, *rdata=NULL;
  39         char *p;
  40
  41         memset(param, 0, sizeof(param));
  42         SSVAL(param,0,hard_link ? SMB_SET_FILE_UNIX_HLINK : SMB_SET_FILE_UNIX_LINK);
  43         p = &param[6];
  44
  45         p += clistr_push(cli, p, fname_src, -1, STR_TERMINATE);
  46         param_len = PTR_DIFF(p, param);
  47
  48         p = data;
  49         p += clistr_push(cli, p, fname_dst, -1, STR_TERMINATE);
  50         data_len = PTR_DIFF(p, data);
  51
  52         if (!cli_send_trans(cli, SMBtrans2,
  53                 NULL,                        /* name */
  54                 -1, 0,                          /* fid, flags */
  55                 &setup, 1, 0,                   /* setup, length, max */
  56                 param, param_len, 2,            /* param, length, max */
  57                 (char *)&data,  data_len, cli->max_xmit /* data, length, max */
  58                 )) {
  59                         return False;
  60         }
  61
  62         if (!cli_receive_trans(cli, SMBtrans2,
  63                 &rparam, &param_len,
  64                 &rdata, &data_len)) {
  65                         return False;
  66         }
  67
  68         SAFE_FREE(rdata);
  69         SAFE_FREE(rparam);
  70
  71         return True;
  72 }
  73
  74 /****************************************************************************
  75  Map standard UNIX permissions onto wire representations.
  76 ****************************************************************************/
  77
  78 uint32  unix_perms_to_wire(mode_t perms)
  79 {
  80         uint ret = 0;
  81
  82         ret |= ((perms & S_IXOTH) ?  UNIX_X_OTH : 0);
  83         ret |= ((perms & S_IWOTH) ?  UNIX_W_OTH : 0);
  84         ret |= ((perms & S_IROTH) ?  UNIX_R_OTH : 0);
  85         ret |= ((perms & S_IXGRP) ?  UNIX_X_GRP : 0);
  86         ret |= ((perms & S_IWGRP) ?  UNIX_W_GRP : 0);
  87         ret |= ((perms & S_IRGRP) ?  UNIX_R_GRP : 0);
  88         ret |= ((perms & S_IXUSR) ?  UNIX_X_USR : 0);
  89         ret |= ((perms & S_IWUSR) ?  UNIX_W_USR : 0);
  90         ret |= ((perms & S_IRUSR) ?  UNIX_R_USR : 0);
  91 #ifdef S_ISVTX
  92         ret |= ((perms & S_ISVTX) ?  UNIX_STICKY : 0);
  93 #endif
  94 #ifdef S_ISGID
  95         ret |= ((perms & S_ISGID) ?  UNIX_SET_GID : 0);
  96 #endif
  97 #ifdef S_ISUID
  98         ret |= ((perms & S_ISVTX) ?  UNIX_SET_UID : 0);
  99 #endif
 100         return ret;
 101 }
 102
 103 /****************************************************************************
 104  Symlink a file (UNIX extensions).
 105 ****************************************************************************/
 106
 107 BOOL cli_unix_symlink(struct cli_state *cli, const char *fname_src, const char *fname_dst)
 108 {
 109         return cli_link_internal(cli, fname_src, fname_dst, False);
 110 }
 111
 112 /****************************************************************************
 113  Hard a file (UNIX extensions).
 114 ****************************************************************************/
 115
 116 BOOL cli_unix_hardlink(struct cli_state *cli, const char *fname_src, const char *fname_dst)
 117 {
 118         return cli_link_internal(cli, fname_src, fname_dst, True);
 119 }
 120
 121 /****************************************************************************
 122  Chmod or chown a file internal (UNIX extensions).
 123 ****************************************************************************/
 124
 125 static BOOL cli_unix_chmod_chown_internal(struct cli_state *cli, const char *fname, uint32 mode, uint32 uid, uint32 gid)
 126 {
 127         int data_len = 0;
 128         int param_len = 0;
 129         uint16 setup = TRANSACT2_SETPATHINFO;
 130         char param[sizeof(pstring)+6];
 131         char data[100];
 132         char *rparam=NULL, *rdata=NULL;
 133         char *p;
 134
 135         memset(param, 0, sizeof(param));
 136         memset(data, 0, sizeof(data));
 137         SSVAL(param,0,SMB_SET_FILE_UNIX_BASIC);
 138         p = &param[6];
 139
 140         p += clistr_push(cli, p, fname, -1, STR_TERMINATE);
 141         param_len = PTR_DIFF(p, param);
 142
 143         SIVAL(data,40,uid);
 144         SIVAL(data,48,gid);
 145         SIVAL(data,84,mode);
 146
 147         data_len = 100;
 148
 149         if (!cli_send_trans(cli, SMBtrans2,
 150                 NULL,                        /* name */
 151                 -1, 0,                          /* fid, flags */
 152                 &setup, 1, 0,                   /* setup, length, max */
 153                 param, param_len, 2,            /* param, length, max */
 154                 (char *)&data,  data_len, cli->max_xmit /* data, length, max */
 155                 )) {
 156                         return False;
 157         }
 158
 159         if (!cli_receive_trans(cli, SMBtrans2,
 160                 &rparam, &param_len,
 161                 &rdata, &data_len)) {
 162                         return False;
 163         }
 164
 165         SAFE_FREE(rdata);
 166         SAFE_FREE(rparam);
 167
 168         return True;
 169 }
 170
 171 /****************************************************************************
 172  chmod a file (UNIX extensions).
 173 ****************************************************************************/
 174
 175 BOOL cli_unix_chmod(struct cli_state *cli, const char *fname, mode_t mode)
 176 {
 177         return cli_unix_chmod_chown_internal(cli, fname,
 178                 unix_perms_to_wire(mode), SMB_UID_NO_CHANGE, SMB_GID_NO_CHANGE);
 179 }
 180
 181 /****************************************************************************
 182  chown a file (UNIX extensions).
 183 ****************************************************************************/
 184
 185 BOOL cli_unix_chown(struct cli_state *cli, const char *fname, uid_t uid, gid_t gid)
 186 {
 187         return cli_unix_chmod_chown_internal(cli, fname, SMB_MODE_NO_CHANGE, (uint32)uid, (uint32)gid);
 188 }
 189
 190 /****************************************************************************
 191  Rename a file.
 192 ****************************************************************************/
 193
 194 BOOL cli_rename(struct cli_state *cli, const char *fname_src, const char *fname_dst)
 195 {
 196         char *p;
 197
 198         memset(cli->outbuf,'\0',smb_size);
 199         memset(cli->inbuf,'\0',smb_size);
 200
 201         set_message(cli->outbuf,1, 0, True);
 202
 203         SCVAL(cli->outbuf,smb_com,SMBmv);
 204         SSVAL(cli->outbuf,smb_tid,cli->cnum);
 205         cli_setup_packet(cli);
 206
 207         SSVAL(cli->outbuf,smb_vwv0,aSYSTEM | aHIDDEN | aDIR);
 208
 209         p = smb_buf(cli->outbuf);
 210         *p++ = 4;
 211         p += clistr_push(cli, p, fname_src, -1, STR_TERMINATE);
 212         *p++ = 4;
 213         p += clistr_push(cli, p, fname_dst, -1, STR_TERMINATE);
 214
 215         cli_setup_bcc(cli, p);
 216
 217         cli_send_smb(cli);
 218         if (!cli_receive_smb(cli))
 219                 return False;
 220
 221         if (cli_is_error(cli))
 222                 return False;
 223
 224         return True;
 225 }
 226
 227 /****************************************************************************
 228  Delete a file.
 229 ****************************************************************************/
 230
 231 BOOL cli_unlink(struct cli_state *cli, const char *fname)
 232 {
 233         char *p;
 234
 235         memset(cli->outbuf,'\0',smb_size);
 236         memset(cli->inbuf,'\0',smb_size);
 237
 238         set_message(cli->outbuf,1, 0,True);
 239
 240         SCVAL(cli->outbuf,smb_com,SMBunlink);
 241         SSVAL(cli->outbuf,smb_tid,cli->cnum);
 242         cli_setup_packet(cli);
 243
 244         SSVAL(cli->outbuf,smb_vwv0,aSYSTEM | aHIDDEN);
 245
 246         p = smb_buf(cli->outbuf);
 247         *p++ = 4;
 248         p += clistr_push(cli, p, fname, -1, STR_TERMINATE);
 249
 250         cli_setup_bcc(cli, p);
 251         cli_send_smb(cli);
 252         if (!cli_receive_smb(cli)) {
 253                 return False;
 254         }
 255
 256         if (cli_is_error(cli)) {
 257                 return False;
 258         }
 259
 260         return True;
 261 }
 262
 263 /****************************************************************************
 264  Create a directory.
 265 ****************************************************************************/
 266
 267 BOOL cli_mkdir(struct cli_state *cli, const char *dname)
 268 {
 269         char *p;
 270
 271         memset(cli->outbuf,'\0',smb_size);
 272         memset(cli->inbuf,'\0',smb_size);
 273
 274         set_message(cli->outbuf,0, 0,True);
 275
 276         SCVAL(cli->outbuf,smb_com,SMBmkdir);
 277         SSVAL(cli->outbuf,smb_tid,cli->cnum);
 278         cli_setup_packet(cli);
 279
 280         p = smb_buf(cli->outbuf);
 281         *p++ = 4;
 282         p += clistr_push(cli, p, dname, -1, STR_TERMINATE);
 283
 284         cli_setup_bcc(cli, p);
 285
 286         cli_send_smb(cli);
 287         if (!cli_receive_smb(cli)) {
 288                 return False;
 289         }
 290
 291         if (cli_is_error(cli)) {
 292                 return False;
 293         }
 294
 295         return True;
 296 }
 297
 298 /****************************************************************************
 299  Remove a directory.
 300 ****************************************************************************/
 301
 302 BOOL cli_rmdir(struct cli_state *cli, const char *dname)
 303 {
 304         char *p;
 305
 306         memset(cli->outbuf,'\0',smb_size);
 307         memset(cli->inbuf,'\0',smb_size);
 308
 309         set_message(cli->outbuf,0, 0, True);
 310
 311         SCVAL(cli->outbuf,smb_com,SMBrmdir);
 312         SSVAL(cli->outbuf,smb_tid,cli->cnum);
 313         cli_setup_packet(cli);
 314
 315         p = smb_buf(cli->outbuf);
 316         *p++ = 4;
 317         p += clistr_push(cli, p, dname, -1, STR_TERMINATE);
 318
 319         cli_setup_bcc(cli, p);
 320
 321         cli_send_smb(cli);
 322         if (!cli_receive_smb(cli)) {
 323                 return False;
 324         }
 325
 326         if (cli_is_error(cli)) {
 327                 return False;
 328         }
 329
 330         return True;
 331 }
 332
 333 /****************************************************************************
 334  Set or clear the delete on close flag.
 335 ****************************************************************************/
 336
 337 int cli_nt_delete_on_close(struct cli_state *cli, int fnum, BOOL flag)
 338 {
 339         int data_len = 1;
 340         int param_len = 6;
 341         uint16 setup = TRANSACT2_SETFILEINFO;
 342         pstring param;
 343         unsigned char data;
 344         char *rparam=NULL, *rdata=NULL;
 345
 346         memset(param, 0, param_len);
 347         SSVAL(param,0,fnum);
 348         SSVAL(param,2,SMB_SET_FILE_DISPOSITION_INFO);
 349
 350         data = flag ? 1 : 0;
 351
 352         if (!cli_send_trans(cli, SMBtrans2,
 353                                                 NULL,                        /* name */
 354                                                 -1, 0,                          /* fid, flags */
 355                                                 &setup, 1, 0,                   /* setup, length, max */
 356                                                 param, param_len, 2,            /* param, length, max */
 357                                                 (char *)&data,  data_len, cli->max_xmit /* data, length, max */
 358                                                 )) {
 359                 return False;
 360         }
 361
 362         if (!cli_receive_trans(cli, SMBtrans2,
 363                                                 &rparam, &param_len,
 364                                                 &rdata, &data_len)) {
 365                 return False;
 366         }
 367
 368         SAFE_FREE(rdata);
 369         SAFE_FREE(rparam);
 370
 371         return True;
 372 }
 373
 374 /****************************************************************************
 375  Open a file - exposing the full horror of the NT API :-).
 376  Used in smbtorture.
 377 ****************************************************************************/
 378
 379 int cli_nt_create_full(struct cli_state *cli, const char *fname, uint32 DesiredAccess,
 380                  uint32 FileAttributes, uint32 ShareAccess,
 381                  uint32 CreateDisposition, uint32 CreateOptions)
 382 {
 383         char *p;
 384         int len;
 385
 386         memset(cli->outbuf,'\0',smb_size);
 387         memset(cli->inbuf,'\0',smb_size);
 388
 389         set_message(cli->outbuf,24,0,True);
 390
 391         SCVAL(cli->outbuf,smb_com,SMBntcreateX);
 392         SSVAL(cli->outbuf,smb_tid,cli->cnum);
 393         cli_setup_packet(cli);
 394
 395         SSVAL(cli->outbuf,smb_vwv0,0xFF);
 396         if (cli->use_oplocks)
 397                 SIVAL(cli->outbuf,smb_ntcreate_Flags, REQUEST_OPLOCK|REQUEST_BATCH_OPLOCK);
 398         else
 399                 SIVAL(cli->outbuf,smb_ntcreate_Flags, 0);
 400         SIVAL(cli->outbuf,smb_ntcreate_RootDirectoryFid, 0x0);
 401         SIVAL(cli->outbuf,smb_ntcreate_DesiredAccess, DesiredAccess);
 402         SIVAL(cli->outbuf,smb_ntcreate_FileAttributes, FileAttributes);
 403         SIVAL(cli->outbuf,smb_ntcreate_ShareAccess, ShareAccess);
 404         SIVAL(cli->outbuf,smb_ntcreate_CreateDisposition, CreateDisposition);
 405         SIVAL(cli->outbuf,smb_ntcreate_CreateOptions, CreateOptions);
 406         SIVAL(cli->outbuf,smb_ntcreate_ImpersonationLevel, 0x02);
 407
 408         p = smb_buf(cli->outbuf);
 409         /* this alignment and termination is critical for netapp filers. Don't change */
 410         p += clistr_align_out(cli, p, 0);
 411         len = clistr_push(cli, p, fname, -1, 0);
 412         p += len;
 413         SSVAL(cli->outbuf,smb_ntcreate_NameLength, len);
 414         /* sigh. this copes with broken netapp filer behaviour */
 415         p += clistr_push(cli, p, "", -1, STR_TERMINATE);
 416
 417         cli_setup_bcc(cli, p);
 418
 419         cli_send_smb(cli);
 420         if (!cli_receive_smb(cli)) {
 421                 return -1;
 422         }
 423
 424         if (cli_is_error(cli)) {
 425                 return -1;
 426         }
 427
 428         return SVAL(cli->inbuf,smb_vwv2 + 1);
 429 }
 430
 431 /****************************************************************************
 432  Open a file.
 433 ****************************************************************************/
 434
 435 int cli_nt_create(struct cli_state *cli, const char *fname, uint32 DesiredAccess)
 436 {
 437         return cli_nt_create_full(cli, fname, DesiredAccess, 0,
 438                                 FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_EXISTS_OPEN, 0x0);
 439 }
 440
 441 /****************************************************************************
 442  Open a file
 443  WARNING: if you open with O_WRONLY then getattrE won't work!
 444 ****************************************************************************/
 445
 446 int cli_open(struct cli_state *cli, const char *fname, int flags, int share_mode)
 447 {
 448         char *p;
 449         unsigned openfn=0;
 450         unsigned accessmode=0;
 451
 452         if (flags & O_CREAT)
 453                 openfn |= (1<<4);
 454         if (!(flags & O_EXCL)) {
 455                 if (flags & O_TRUNC)
 456                         openfn |= (1<<1);
 457                 else
 458                         openfn |= (1<<0);
 459         }
 460
 461         accessmode = (share_mode<<4);
 462
 463         if ((flags & O_ACCMODE) == O_RDWR) {
 464                 accessmode |= 2;
 465         } else if ((flags & O_ACCMODE) == O_WRONLY) {
 466                 accessmode |= 1;
 467         }
 468
 469 #if defined(O_SYNC)
 470         if ((flags & O_SYNC) == O_SYNC) {
 471                 accessmode |= (1<<14);
 472         }
 473 #endif /* O_SYNC */
 474
 475         if (share_mode == DENY_FCB) {
 476                 accessmode = 0xFF;
 477         }
 478
 479         memset(cli->outbuf,'\0',smb_size);
 480         memset(cli->inbuf,'\0',smb_size);
 481
 482         set_message(cli->outbuf,15,0,True);
 483
 484         SCVAL(cli->outbuf,smb_com,SMBopenX);
 485         SSVAL(cli->outbuf,smb_tid,cli->cnum);
 486         cli_setup_packet(cli);
 487
 488         SSVAL(cli->outbuf,smb_vwv0,0xFF);
 489         SSVAL(cli->outbuf,smb_vwv2,0);  /* no additional info */
 490         SSVAL(cli->outbuf,smb_vwv3,accessmode);
 491         SSVAL(cli->outbuf,smb_vwv4,aSYSTEM | aHIDDEN);
 492         SSVAL(cli->outbuf,smb_vwv5,0);
 493         SSVAL(cli->outbuf,smb_vwv8,openfn);
 494
 495         if (cli->use_oplocks) {
 496                 /* if using oplocks then ask for a batch oplock via
 497                    core and extended methods */
 498                 SCVAL(cli->outbuf,smb_flg, CVAL(cli->outbuf,smb_flg)|
 499                         FLAG_REQUEST_OPLOCK|FLAG_REQUEST_BATCH_OPLOCK);
 500                 SSVAL(cli->outbuf,smb_vwv2,SVAL(cli->outbuf,smb_vwv2) | 6);
 501         }
 502
 503         p = smb_buf(cli->outbuf);
 504         p += clistr_push(cli, p, fname, -1, STR_TERMINATE);
 505
 506         cli_setup_bcc(cli, p);
 507
 508         cli_send_smb(cli);
 509         if (!cli_receive_smb(cli)) {
 510                 return -1;
 511         }
 512
 513         if (cli_is_error(cli)) {
 514                 return -1;
 515         }
 516
 517         return SVAL(cli->inbuf,smb_vwv2);
 518 }
 519
 520 /****************************************************************************
 521  Close a file.
 522 ****************************************************************************/
 523
 524 BOOL cli_close(struct cli_state *cli, int fnum)
 525 {
 526         memset(cli->outbuf,'\0',smb_size);
 527         memset(cli->inbuf,'\0',smb_size);
 528
 529         set_message(cli->outbuf,3,0,True);
 530
 531         SCVAL(cli->outbuf,smb_com,SMBclose);
 532         SSVAL(cli->outbuf,smb_tid,cli->cnum);
 533         cli_setup_packet(cli);
 534
 535         SSVAL(cli->outbuf,smb_vwv0,fnum);
 536         SIVALS(cli->outbuf,smb_vwv1,-1);
 537
 538         cli_send_smb(cli);
 539         if (!cli_receive_smb(cli)) {
 540                 return False;
 541         }
 542
 543         return !cli_is_error(cli);
 544 }
 545
 546 /****************************************************************************
 547  Lock a file.
 548 ****************************************************************************/
 549
 550 BOOL cli_lock(struct cli_state *cli, int fnum,
 551               uint32 offset, uint32 len, int timeout, enum brl_type lock_type)
 552 {
 553         char *p;
 554         int saved_timeout = cli->timeout;
 555
 556         memset(cli->outbuf,'\0',smb_size);
 557         memset(cli->inbuf,'\0', smb_size);
 558
 559         set_message(cli->outbuf,8,0,True);
 560
 561         SCVAL(cli->outbuf,smb_com,SMBlockingX);
 562         SSVAL(cli->outbuf,smb_tid,cli->cnum);
 563         cli_setup_packet(cli);
 564
 565         SCVAL(cli->outbuf,smb_vwv0,0xFF);
 566         SSVAL(cli->outbuf,smb_vwv2,fnum);
 567         SCVAL(cli->outbuf,smb_vwv3,(lock_type == READ_LOCK? 1 : 0));
 568         SIVALS(cli->outbuf, smb_vwv4, timeout);
 569         SSVAL(cli->outbuf,smb_vwv6,0);
 570         SSVAL(cli->outbuf,smb_vwv7,1);
 571
 572         p = smb_buf(cli->outbuf);
 573         SSVAL(p, 0, cli->pid);
 574         SIVAL(p, 2, offset);
 575         SIVAL(p, 6, len);
 576
 577         p += 10;
 578
 579         cli_setup_bcc(cli, p);
 580
 581         cli_send_smb(cli);
 582
 583         cli->timeout = (timeout == -1) ? 0x7FFFFFFF : (timeout + 2*1000);
 584
 585         if (!cli_receive_smb(cli)) {
 586                 cli->timeout = saved_timeout;
 587                 return False;
 588         }
 589
 590         cli->timeout = saved_timeout;
 591
 592         if (cli_is_error(cli)) {
 593                 return False;
 594         }
 595
 596         return True;
 597 }
 598
 599 /****************************************************************************
 600  Unlock a file.
 601 ****************************************************************************/
 602
 603 BOOL cli_unlock(struct cli_state *cli, int fnum, uint32 offset, uint32 len)
 604 {
 605         char *p;
 606
 607         memset(cli->outbuf,'\0',smb_size);
 608         memset(cli->inbuf,'\0',smb_size);
 609
 610         set_message(cli->outbuf,8,0,True);
 611
 612         SCVAL(cli->outbuf,smb_com,SMBlockingX);
 613         SSVAL(cli->outbuf,smb_tid,cli->cnum);
 614         cli_setup_packet(cli);
 615
 616         SCVAL(cli->outbuf,smb_vwv0,0xFF);
 617         SSVAL(cli->outbuf,smb_vwv2,fnum);
 618         SCVAL(cli->outbuf,smb_vwv3,0);
 619         SIVALS(cli->outbuf, smb_vwv4, 0);
 620         SSVAL(cli->outbuf,smb_vwv6,1);
 621         SSVAL(cli->outbuf,smb_vwv7,0);
 622
 623         p = smb_buf(cli->outbuf);
 624         SSVAL(p, 0, cli->pid);
 625         SIVAL(p, 2, offset);
 626         SIVAL(p, 6, len);
 627         p += 10;
 628         cli_setup_bcc(cli, p);
 629         cli_send_smb(cli);
 630         if (!cli_receive_smb(cli)) {
 631                 return False;
 632         }
 633
 634         if (cli_is_error(cli)) {
 635                 return False;
 636         }
 637
 638         return True;
 639 }
 640
 641 /****************************************************************************
 642  Lock a file with 64 bit offsets.
 643 ****************************************************************************/
 644
 645 BOOL cli_lock64(struct cli_state *cli, int fnum,
 646                 SMB_BIG_UINT offset, SMB_BIG_UINT len, int timeout, enum brl_type lock_type)
 647 {
 648         char *p;
 649         int saved_timeout = cli->timeout;
 650         int ltype;
 651
 652         if (! (cli->capabilities & CAP_LARGE_FILES)) {
 653                 return cli_lock(cli, fnum, offset, len, timeout, lock_type);
 654         }
 655
 656         ltype = (lock_type == READ_LOCK? 1 : 0);
 657         ltype |= LOCKING_ANDX_LARGE_FILES;
 658
 659         memset(cli->outbuf,'\0',smb_size);
 660         memset(cli->inbuf,'\0', smb_size);
 661
 662         set_message(cli->outbuf,8,0,True);
 663
 664         SCVAL(cli->outbuf,smb_com,SMBlockingX);
 665         SSVAL(cli->outbuf,smb_tid,cli->cnum);
 666         cli_setup_packet(cli);
 667
 668         SCVAL(cli->outbuf,smb_vwv0,0xFF);
 669         SSVAL(cli->outbuf,smb_vwv2,fnum);
 670         SCVAL(cli->outbuf,smb_vwv3,ltype);
 671         SIVALS(cli->outbuf, smb_vwv4, timeout);
 672         SSVAL(cli->outbuf,smb_vwv6,0);
 673         SSVAL(cli->outbuf,smb_vwv7,1);
 674
 675         p = smb_buf(cli->outbuf);
 676         SIVAL(p, 0, cli->pid);
 677         SOFF_T_R(p, 4, offset);
 678         SOFF_T_R(p, 12, len);
 679         p += 20;
 680
 681         cli_setup_bcc(cli, p);
 682         cli_send_smb(cli);
 683
 684         cli->timeout = (timeout == -1) ? 0x7FFFFFFF : (timeout + 2*1000);
 685
 686         if (!cli_receive_smb(cli)) {
 687                 cli->timeout = saved_timeout;
 688                 return False;
 689         }
 690
 691         cli->timeout = saved_timeout;
 692
 693         if (cli_is_error(cli)) {
 694                 return False;
 695         }
 696
 697         return True;
 698 }
 699
 700 /****************************************************************************
 701  Unlock a file with 64 bit offsets.
 702 ****************************************************************************/
 703
 704 BOOL cli_unlock64(struct cli_state *cli, int fnum, SMB_BIG_UINT offset, SMB_BIG_UINT len)
 705 {
 706         char *p;
 707
 708         if (! (cli->capabilities & CAP_LARGE_FILES)) {
 709                 return cli_unlock(cli, fnum, offset, len);
 710         }
 711
 712         memset(cli->outbuf,'\0',smb_size);
 713         memset(cli->inbuf,'\0',smb_size);
 714
 715         set_message(cli->outbuf,8,0,True);
 716
 717         SCVAL(cli->outbuf,smb_com,SMBlockingX);
 718         SSVAL(cli->outbuf,smb_tid,cli->cnum);
 719         cli_setup_packet(cli);
 720
 721         SCVAL(cli->outbuf,smb_vwv0,0xFF);
 722         SSVAL(cli->outbuf,smb_vwv2,fnum);
 723         SCVAL(cli->outbuf,smb_vwv3,LOCKING_ANDX_LARGE_FILES);
 724         SIVALS(cli->outbuf, smb_vwv4, 0);
 725         SSVAL(cli->outbuf,smb_vwv6,1);
 726         SSVAL(cli->outbuf,smb_vwv7,0);
 727
 728         p = smb_buf(cli->outbuf);
 729         SIVAL(p, 0, cli->pid);
 730         SOFF_T_R(p, 4, offset);
 731         SOFF_T_R(p, 12, len);
 732         p += 20;
 733         cli_setup_bcc(cli, p);
 734         cli_send_smb(cli);
 735         if (!cli_receive_smb(cli)) {
 736                 return False;
 737         }
 738
 739         if (cli_is_error(cli)) {
 740                 return False;
 741         }
 742
 743         return True;
 744 }
 745
 746 /****************************************************************************
 747  Do a SMBgetattrE call.
 748 ****************************************************************************/
 749
 750 BOOL cli_getattrE(struct cli_state *cli, int fd,
 751                   uint16 *attr, size_t *size,
 752                   time_t *c_time, time_t *a_time, time_t *m_time)
 753 {
 754         memset(cli->outbuf,'\0',smb_size);
 755         memset(cli->inbuf,'\0',smb_size);
 756
 757         set_message(cli->outbuf,1,0,True);
 758
 759         SCVAL(cli->outbuf,smb_com,SMBgetattrE);
 760         SSVAL(cli->outbuf,smb_tid,cli->cnum);
 761         cli_setup_packet(cli);
 762
 763         SSVAL(cli->outbuf,smb_vwv0,fd);
 764
 765         cli_send_smb(cli);
 766         if (!cli_receive_smb(cli)) {
 767                 return False;
 768         }
 769
 770         if (cli_is_error(cli)) {
 771                 return False;
 772         }
 773
 774         if (size) {
 775                 *size = IVAL(cli->inbuf, smb_vwv6);
 776         }
 777
 778         if (attr) {
 779                 *attr = SVAL(cli->inbuf,smb_vwv10);
 780         }
 781
 782         if (c_time) {
 783                 *c_time = make_unix_date3(cli->inbuf+smb_vwv0);
 784         }
 785
 786         if (a_time) {
 787                 *a_time = make_unix_date3(cli->inbuf+smb_vwv2);
 788         }
 789
 790         if (m_time) {
 791                 *m_time = make_unix_date3(cli->inbuf+smb_vwv4);
 792         }
 793
 794         return True;
 795 }
 796
 797 /****************************************************************************
 798  Do a SMBgetatr call
 799 ****************************************************************************/
 800
 801 BOOL cli_getatr(struct cli_state *cli, const char *fname,
 802                 uint16 *attr, size_t *size, time_t *t)
 803 {
 804         char *p;
 805
 806         memset(cli->outbuf,'\0',smb_size);
 807         memset(cli->inbuf,'\0',smb_size);
 808
 809         set_message(cli->outbuf,0,0,True);
 810
 811         SCVAL(cli->outbuf,smb_com,SMBgetatr);
 812         SSVAL(cli->outbuf,smb_tid,cli->cnum);
 813         cli_setup_packet(cli);
 814
 815         p = smb_buf(cli->outbuf);
 816         *p++ = 4;
 817         p += clistr_push(cli, p, fname, -1, STR_TERMINATE);
 818
 819         cli_setup_bcc(cli, p);
 820
 821         cli_send_smb(cli);
 822         if (!cli_receive_smb(cli)) {
 823                 return False;
 824         }
 825
 826         if (cli_is_error(cli)) {
 827                 return False;
 828         }
 829
 830         if (size) {
 831                 *size = IVAL(cli->inbuf, smb_vwv3);
 832         }
 833
 834         if (t) {
 835                 *t = make_unix_date3(cli->inbuf+smb_vwv1);
 836         }
 837
 838         if (attr) {
 839                 *attr = SVAL(cli->inbuf,smb_vwv0);
 840         }
 841
 842
 843         return True;
 844 }
 845
 846 /****************************************************************************
 847  Do a SMBsetatr call.
 848 ****************************************************************************/
 849
 850 BOOL cli_setatr(struct cli_state *cli, const char *fname, uint16 attr, time_t t)
 851 {
 852         char *p;
 853
 854         memset(cli->outbuf,'\0',smb_size);
 855         memset(cli->inbuf,'\0',smb_size);
 856
 857         set_message(cli->outbuf,8,0,True);
 858
 859         SCVAL(cli->outbuf,smb_com,SMBsetatr);
 860         SSVAL(cli->outbuf,smb_tid,cli->cnum);
 861         cli_setup_packet(cli);
 862
 863         SSVAL(cli->outbuf,smb_vwv0, attr);
 864         put_dos_date3(cli->outbuf,smb_vwv1, t);
 865
 866         p = smb_buf(cli->outbuf);
 867         *p++ = 4;
 868         p += clistr_push(cli, p, fname, -1, STR_TERMINATE);
 869         *p++ = 4;
 870
 871         cli_setup_bcc(cli, p);
 872
 873         cli_send_smb(cli);
 874         if (!cli_receive_smb(cli)) {
 875                 return False;
 876         }
 877
 878         if (cli_is_error(cli)) {
 879                 return False;
 880         }
 881
 882         return True;
 883 }
 884
 885 /****************************************************************************
 886  Check for existance of a dir.
 887 ****************************************************************************/
 888
 889 BOOL cli_chkpath(struct cli_state *cli, const char *path)
 890 {
 891         pstring path2;
 892         char *p;
 893
 894         safe_strcpy(path2,path,sizeof(pstring));
 895         trim_string(path2,NULL,"\\");
 896         if (!*path2) *path2 = '\\';
 897
 898         memset(cli->outbuf,'\0',smb_size);
 899         set_message(cli->outbuf,0,0,True);
 900         SCVAL(cli->outbuf,smb_com,SMBchkpth);
 901         SSVAL(cli->outbuf,smb_tid,cli->cnum);
 902         cli_setup_packet(cli);
 903         p = smb_buf(cli->outbuf);
 904         *p++ = 4;
 905         p += clistr_push(cli, p, path2, -1, STR_TERMINATE);
 906
 907         cli_setup_bcc(cli, p);
 908
 909         cli_send_smb(cli);
 910         if (!cli_receive_smb(cli)) {
 911                 return False;
 912         }
 913
 914         if (cli_is_error(cli)) return False;
 915
 916         return True;
 917 }
 918
 919 /****************************************************************************
 920  Query disk space.
 921 ****************************************************************************/
 922
 923 BOOL cli_dskattr(struct cli_state *cli, int *bsize, int *total, int *avail)
 924 {
 925         memset(cli->outbuf,'\0',smb_size);
 926         set_message(cli->outbuf,0,0,True);
 927         SCVAL(cli->outbuf,smb_com,SMBdskattr);
 928         SSVAL(cli->outbuf,smb_tid,cli->cnum);
 929         cli_setup_packet(cli);
 930
 931         cli_send_smb(cli);
 932         if (!cli_receive_smb(cli)) {
 933                 return False;
 934         }
 935
 936         *bsize = SVAL(cli->inbuf,smb_vwv1)*SVAL(cli->inbuf,smb_vwv2);
 937         *total = SVAL(cli->inbuf,smb_vwv0);
 938         *avail = SVAL(cli->inbuf,smb_vwv3);
 939
 940         return True;
 941 }
 942
 943 /****************************************************************************
 944  Create and open a temporary file.
 945 ****************************************************************************/
 946
 947 int cli_ctemp(struct cli_state *cli, const char *path, char **tmp_path)
 948 {
 949         int len;
 950         char *p;
 951
 952         memset(cli->outbuf,'\0',smb_size);
 953         memset(cli->inbuf,'\0',smb_size);
 954
 955         set_message(cli->outbuf,3,0,True);
 956
 957         SCVAL(cli->outbuf,smb_com,SMBctemp);
 958         SSVAL(cli->outbuf,smb_tid,cli->cnum);
 959         cli_setup_packet(cli);
 960
 961         SSVAL(cli->outbuf,smb_vwv0,0);
 962         SIVALS(cli->outbuf,smb_vwv1,-1);
 963
 964         p = smb_buf(cli->outbuf);
 965         *p++ = 4;
 966         p += clistr_push(cli, p, path, -1, STR_TERMINATE);
 967
 968         cli_setup_bcc(cli, p);
 969
 970         cli_send_smb(cli);
 971         if (!cli_receive_smb(cli)) {
 972                 return -1;
 973         }
 974
 975         if (cli_is_error(cli)) {
 976                 return -1;
 977         }
 978
 979         /* despite the spec, the result has a -1, followed by
 980            length, followed by name */
 981         p = smb_buf(cli->inbuf);
 982         p += 4;
 983         len = smb_buflen(cli->inbuf) - 4;
 984         if (len <= 0) return -1;
 985
 986         if (tmp_path) {
 987                 pstring path2;
 988                 clistr_pull(cli, path2, p,
 989                             sizeof(path2), len, STR_ASCII);
 990                 *tmp_path = strdup(path2);
 991         }
 992
 993         return SVAL(cli->inbuf,smb_vwv0);
 994 }