source3/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
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20 */
  21
  22 #define NO_SYSLOG
  23
  24 #include "includes.h"
  25
  26 /****************************************************************************
  27 rename a file
  28 ****************************************************************************/
  29 BOOL cli_rename(struct cli_state *cli, char *fname_src, char *fname_dst)
  30 {
  31         char *p;
  32
  33         memset(cli->outbuf,'\0',smb_size);
  34         memset(cli->inbuf,'\0',smb_size);
  35
  36         set_message(cli->outbuf,1, 0, True);
  37
  38         CVAL(cli->outbuf,smb_com) = SMBmv;
  39         SSVAL(cli->outbuf,smb_tid,cli->cnum);
  40         cli_setup_packet(cli);
  41
  42         SSVAL(cli->outbuf,smb_vwv0,aSYSTEM | aHIDDEN | aDIR);
  43
  44         p = smb_buf(cli->outbuf);
  45         *p++ = 4;
  46         p += clistr_push(cli, p, fname_src, -1,
  47                          CLISTR_TERMINATE | CLISTR_CONVERT);
  48         *p++ = 4;
  49         p += clistr_push(cli, p, fname_dst, -1,
  50                          CLISTR_TERMINATE | CLISTR_CONVERT);
  51
  52         cli_setup_bcc(cli, p);
  53
  54         cli_send_smb(cli);
  55         if (!cli_receive_smb(cli)) {
  56                 return False;
  57         }
  58
  59         if (CVAL(cli->inbuf,smb_rcls) != 0) {
  60                 return False;
  61         }
  62
  63         return True;
  64 }
  65
  66 /****************************************************************************
  67 delete a file
  68 ****************************************************************************/
  69 BOOL cli_unlink(struct cli_state *cli, char *fname)
  70 {
  71         char *p;
  72
  73         memset(cli->outbuf,'\0',smb_size);
  74         memset(cli->inbuf,'\0',smb_size);
  75
  76         set_message(cli->outbuf,1, 0,True);
  77
  78         CVAL(cli->outbuf,smb_com) = SMBunlink;
  79         SSVAL(cli->outbuf,smb_tid,cli->cnum);
  80         cli_setup_packet(cli);
  81
  82         SSVAL(cli->outbuf,smb_vwv0,aSYSTEM | aHIDDEN);
  83
  84         p = smb_buf(cli->outbuf);
  85         *p++ = 4;
  86         p += clistr_push(cli, p, fname, -1, CLISTR_TERMINATE | CLISTR_CONVERT);
  87
  88         cli_setup_bcc(cli, p);
  89         cli_send_smb(cli);
  90         if (!cli_receive_smb(cli)) {
  91                 return False;
  92         }
  93
  94         if (CVAL(cli->inbuf,smb_rcls) != 0) {
  95                 return False;
  96         }
  97
  98         return True;
  99 }
 100
 101 /****************************************************************************
 102 create a directory
 103 ****************************************************************************/
 104 BOOL cli_mkdir(struct cli_state *cli, char *dname)
 105 {
 106         char *p;
 107
 108         memset(cli->outbuf,'\0',smb_size);
 109         memset(cli->inbuf,'\0',smb_size);
 110
 111         set_message(cli->outbuf,0, 0,True);
 112
 113         CVAL(cli->outbuf,smb_com) = SMBmkdir;
 114         SSVAL(cli->outbuf,smb_tid,cli->cnum);
 115         cli_setup_packet(cli);
 116
 117         p = smb_buf(cli->outbuf);
 118         *p++ = 4;
 119         p += clistr_push(cli, p, dname, -1, CLISTR_CONVERT|CLISTR_TERMINATE);
 120
 121         cli_setup_bcc(cli, p);
 122
 123         cli_send_smb(cli);
 124         if (!cli_receive_smb(cli)) {
 125                 return False;
 126         }
 127
 128         if (CVAL(cli->inbuf,smb_rcls) != 0) {
 129                 return False;
 130         }
 131
 132         return True;
 133 }
 134
 135 /****************************************************************************
 136 remove a directory
 137 ****************************************************************************/
 138 BOOL cli_rmdir(struct cli_state *cli, char *dname)
 139 {
 140         char *p;
 141
 142         memset(cli->outbuf,'\0',smb_size);
 143         memset(cli->inbuf,'\0',smb_size);
 144
 145         set_message(cli->outbuf,0, 0, True);
 146
 147         CVAL(cli->outbuf,smb_com) = SMBrmdir;
 148         SSVAL(cli->outbuf,smb_tid,cli->cnum);
 149         cli_setup_packet(cli);
 150
 151         p = smb_buf(cli->outbuf);
 152         *p++ = 4;
 153         p += clistr_push(cli, p, dname, -1, CLISTR_TERMINATE|CLISTR_CONVERT);
 154
 155         cli_setup_bcc(cli, p);
 156
 157         cli_send_smb(cli);
 158         if (!cli_receive_smb(cli)) {
 159                 return False;
 160         }
 161
 162         if (CVAL(cli->inbuf,smb_rcls) != 0) {
 163                 return False;
 164         }
 165
 166         return True;
 167 }
 168
 169 /****************************************************************************
 170 open a file
 171 ****************************************************************************/
 172 int cli_nt_create(struct cli_state *cli, char *fname, uint32 DesiredAccess)
 173 {
 174         char *p;
 175
 176         memset(cli->outbuf,'\0',smb_size);
 177         memset(cli->inbuf,'\0',smb_size);
 178
 179         set_message(cli->outbuf,24,0,True);
 180
 181         CVAL(cli->outbuf,smb_com) = SMBntcreateX;
 182         SSVAL(cli->outbuf,smb_tid,cli->cnum);
 183         cli_setup_packet(cli);
 184
 185         SSVAL(cli->outbuf,smb_vwv0,0xFF);
 186         if (cli->use_oplocks)
 187                 SIVAL(cli->outbuf,smb_ntcreate_Flags, REQUEST_OPLOCK|REQUEST_BATCH_OPLOCK);
 188         else
 189                 SIVAL(cli->outbuf,smb_ntcreate_Flags, 0);
 190         SIVAL(cli->outbuf,smb_ntcreate_RootDirectoryFid, 0x0);
 191         SIVAL(cli->outbuf,smb_ntcreate_DesiredAccess, DesiredAccess);
 192         SIVAL(cli->outbuf,smb_ntcreate_FileAttributes, 0x0);
 193         SIVAL(cli->outbuf,smb_ntcreate_ShareAccess, 0x03);
 194         SIVAL(cli->outbuf,smb_ntcreate_CreateDisposition, 0x01);
 195         SIVAL(cli->outbuf,smb_ntcreate_CreateOptions, 0x0);
 196         SIVAL(cli->outbuf,smb_ntcreate_ImpersonationLevel, 0x02);
 197         SSVAL(cli->outbuf,smb_ntcreate_NameLength, strlen(fname));
 198
 199         p = smb_buf(cli->outbuf);
 200         p += clistr_push(cli, p, fname, -1, CLISTR_TERMINATE | CLISTR_CONVERT);
 201
 202         cli_setup_bcc(cli, p);
 203
 204         cli_send_smb(cli);
 205         if (!cli_receive_smb(cli)) {
 206                 return -1;
 207         }
 208
 209         if (CVAL(cli->inbuf,smb_rcls) != 0) {
 210                 return -1;
 211         }
 212
 213         return SVAL(cli->inbuf,smb_vwv2 + 1);
 214 }
 215
 216 /****************************************************************************
 217 open a file
 218 ****************************************************************************/
 219 int cli_nt_create_uni(struct cli_state *cli, char *fname, uint32 DesiredAccess)
 220 {
 221         pstring uni;
 222         char *p;
 223
 224         memset(cli->outbuf,'\0',smb_size);
 225         memset(cli->inbuf,'\0',smb_size);
 226
 227         set_message(cli->outbuf,24,(strlen(fname) + 1) * 2 + 1,True);
 228
 229         CVAL(cli->outbuf,smb_com) = SMBntcreateX;
 230         SSVAL(cli->outbuf,smb_tid,cli->cnum);
 231         cli_setup_packet(cli);
 232
 233         SSVAL(cli->outbuf,smb_vwv0,0xFF);
 234         if (cli->use_oplocks)
 235                 SIVAL(cli->outbuf,smb_ntcreate_Flags, REQUEST_OPLOCK|REQUEST_BATCH_OPLOCK);
 236         else
 237                 SIVAL(cli->outbuf,smb_ntcreate_Flags, 0);
 238         SIVAL(cli->outbuf,smb_ntcreate_RootDirectoryFid, 0x0);
 239         SIVAL(cli->outbuf,smb_ntcreate_DesiredAccess, DesiredAccess);
 240         SIVAL(cli->outbuf,smb_ntcreate_FileAttributes, 0x0);
 241         SIVAL(cli->outbuf,smb_ntcreate_ShareAccess, 0x03);
 242         SIVAL(cli->outbuf,smb_ntcreate_CreateDisposition, 0x01);
 243         SIVAL(cli->outbuf,smb_ntcreate_CreateOptions, 0x0);
 244         SIVAL(cli->outbuf,smb_ntcreate_ImpersonationLevel, 0x02);
 245         SSVAL(cli->outbuf,smb_ntcreate_NameLength, strlen(fname) * 2);
 246
 247         p = smb_buf(cli->outbuf);
 248         p++; /* Alignment */
 249         pstrcpy(uni, fname);
 250         unix_to_dos(uni, True);
 251         dos_struni2(p, uni, (strlen(fname) + 1) * 2);
 252
 253         cli_send_smb(cli);
 254         if (!cli_receive_smb(cli)) {
 255                 return -1;
 256         }
 257
 258         if (CVAL(cli->inbuf,smb_rcls) != 0) {
 259                 return -1;
 260         }
 261
 262         return SVAL(cli->inbuf,smb_vwv2 + 1);
 263 }
 264
 265
 266 /****************************************************************************
 267 open a file
 268 WARNING: if you open with O_WRONLY then getattrE won't work!
 269 ****************************************************************************/
 270 int cli_open(struct cli_state *cli, char *fname, int flags, int share_mode)
 271 {
 272         char *p;
 273         unsigned openfn=0;
 274         unsigned accessmode=0;
 275
 276         if (flags & O_CREAT)
 277                 openfn |= (1<<4);
 278         if (!(flags & O_EXCL)) {
 279                 if (flags & O_TRUNC)
 280                         openfn |= (1<<1);
 281                 else
 282                         openfn |= (1<<0);
 283         }
 284
 285         accessmode = (share_mode<<4);
 286
 287         if ((flags & O_ACCMODE) == O_RDWR) {
 288                 accessmode |= 2;
 289         } else if ((flags & O_ACCMODE) == O_WRONLY) {
 290                 accessmode |= 1;
 291         }
 292
 293 #if defined(O_SYNC)
 294         if ((flags & O_SYNC) == O_SYNC) {
 295                 accessmode |= (1<<14);
 296         }
 297 #endif /* O_SYNC */
 298
 299         if (share_mode == DENY_FCB) {
 300                 accessmode = 0xFF;
 301         }
 302
 303         memset(cli->outbuf,'\0',smb_size);
 304         memset(cli->inbuf,'\0',smb_size);
 305
 306         set_message(cli->outbuf,15,0,True);
 307
 308         CVAL(cli->outbuf,smb_com) = SMBopenX;
 309         SSVAL(cli->outbuf,smb_tid,cli->cnum);
 310         cli_setup_packet(cli);
 311
 312         SSVAL(cli->outbuf,smb_vwv0,0xFF);
 313         SSVAL(cli->outbuf,smb_vwv2,0);  /* no additional info */
 314         SSVAL(cli->outbuf,smb_vwv3,accessmode);
 315         SSVAL(cli->outbuf,smb_vwv4,aSYSTEM | aHIDDEN);
 316         SSVAL(cli->outbuf,smb_vwv5,0);
 317         SSVAL(cli->outbuf,smb_vwv8,openfn);
 318
 319         if (cli->use_oplocks) {
 320                 /* if using oplocks then ask for a batch oplock via
 321                    core and extended methods */
 322                 CVAL(cli->outbuf,smb_flg) |=
 323                         FLAG_REQUEST_OPLOCK|FLAG_REQUEST_BATCH_OPLOCK;
 324                 SSVAL(cli->outbuf,smb_vwv2,SVAL(cli->outbuf,smb_vwv2) | 6);
 325         }
 326
 327         p = smb_buf(cli->outbuf);
 328         p += clistr_push(cli, p, fname, -1, CLISTR_TERMINATE | CLISTR_CONVERT);
 329
 330         cli_setup_bcc(cli, p);
 331
 332         cli_send_smb(cli);
 333         if (!cli_receive_smb(cli)) {
 334                 return -1;
 335         }
 336
 337         if (CVAL(cli->inbuf,smb_rcls) != 0) {
 338                 return -1;
 339         }
 340
 341         return SVAL(cli->inbuf,smb_vwv2);
 342 }
 343
 344
 345
 346
 347 /****************************************************************************
 348   close a file
 349 ****************************************************************************/
 350 BOOL cli_close(struct cli_state *cli, int fnum)
 351 {
 352         memset(cli->outbuf,'\0',smb_size);
 353         memset(cli->inbuf,'\0',smb_size);
 354
 355         set_message(cli->outbuf,3,0,True);
 356
 357         CVAL(cli->outbuf,smb_com) = SMBclose;
 358         SSVAL(cli->outbuf,smb_tid,cli->cnum);
 359         cli_setup_packet(cli);
 360
 361         SSVAL(cli->outbuf,smb_vwv0,fnum);
 362         SIVALS(cli->outbuf,smb_vwv1,-1);
 363
 364         cli_send_smb(cli);
 365         if (!cli_receive_smb(cli)) {
 366                 return False;
 367         }
 368
 369         if (CVAL(cli->inbuf,smb_rcls) != 0) {
 370                 return False;
 371         }
 372
 373         return True;
 374 }
 375
 376
 377 /****************************************************************************
 378   lock a file
 379 ****************************************************************************/
 380 BOOL cli_lock(struct cli_state *cli, int fnum,
 381               uint32 offset, uint32 len, int timeout, enum brl_type lock_type)
 382 {
 383         char *p;
 384         int saved_timeout = cli->timeout;
 385
 386         memset(cli->outbuf,'\0',smb_size);
 387         memset(cli->inbuf,'\0', smb_size);
 388
 389         set_message(cli->outbuf,8,10,True);
 390
 391         CVAL(cli->outbuf,smb_com) = SMBlockingX;
 392         SSVAL(cli->outbuf,smb_tid,cli->cnum);
 393         cli_setup_packet(cli);
 394
 395         CVAL(cli->outbuf,smb_vwv0) = 0xFF;
 396         SSVAL(cli->outbuf,smb_vwv2,fnum);
 397         CVAL(cli->outbuf,smb_vwv3) = (lock_type == READ_LOCK? 1 : 0);
 398         SIVALS(cli->outbuf, smb_vwv4, timeout);
 399         SSVAL(cli->outbuf,smb_vwv6,0);
 400         SSVAL(cli->outbuf,smb_vwv7,1);
 401
 402         p = smb_buf(cli->outbuf);
 403         SSVAL(p, 0, cli->pid);
 404         SIVAL(p, 2, offset);
 405         SIVAL(p, 6, len);
 406         cli_send_smb(cli);
 407
 408         cli->timeout = (timeout == -1) ? 0x7FFFFFFF : (timeout + 2*1000);
 409
 410         if (!cli_receive_smb(cli)) {
 411                 cli->timeout = saved_timeout;
 412                 return False;
 413         }
 414
 415         cli->timeout = saved_timeout;
 416
 417         if (CVAL(cli->inbuf,smb_rcls) != 0) {
 418                 return False;
 419         }
 420
 421         return True;
 422 }
 423
 424 /****************************************************************************
 425   unlock a file
 426 ****************************************************************************/
 427 BOOL cli_unlock(struct cli_state *cli, int fnum, uint32 offset, uint32 len)
 428 {
 429         char *p;
 430
 431         memset(cli->outbuf,'\0',smb_size);
 432         memset(cli->inbuf,'\0',smb_size);
 433
 434         set_message(cli->outbuf,8,10,True);
 435
 436         CVAL(cli->outbuf,smb_com) = SMBlockingX;
 437         SSVAL(cli->outbuf,smb_tid,cli->cnum);
 438         cli_setup_packet(cli);
 439
 440         CVAL(cli->outbuf,smb_vwv0) = 0xFF;
 441         SSVAL(cli->outbuf,smb_vwv2,fnum);
 442         CVAL(cli->outbuf,smb_vwv3) = 0;
 443         SIVALS(cli->outbuf, smb_vwv4, 0);
 444         SSVAL(cli->outbuf,smb_vwv6,1);
 445         SSVAL(cli->outbuf,smb_vwv7,0);
 446
 447         p = smb_buf(cli->outbuf);
 448         SSVAL(p, 0, cli->pid);
 449         SIVAL(p, 2, offset);
 450         SIVAL(p, 6, len);
 451
 452         cli_send_smb(cli);
 453         if (!cli_receive_smb(cli)) {
 454                 return False;
 455         }
 456
 457         if (CVAL(cli->inbuf,smb_rcls) != 0) {
 458                 return False;
 459         }
 460
 461         return True;
 462 }
 463
 464
 465 /****************************************************************************
 466   lock a file with 64 bit offsets
 467 ****************************************************************************/
 468 BOOL cli_lock64(struct cli_state *cli, int fnum,
 469                 SMB_BIG_UINT offset, SMB_BIG_UINT len, int timeout, enum brl_type lock_type)
 470 {
 471         char *p;
 472         int saved_timeout = cli->timeout;
 473         int ltype;
 474
 475         ltype = (lock_type == READ_LOCK? 1 : 0);
 476         ltype |= LOCKING_ANDX_LARGE_FILES;
 477
 478         memset(cli->outbuf,'\0',smb_size);
 479         memset(cli->inbuf,'\0', smb_size);
 480
 481         set_message(cli->outbuf,8,20,True);
 482
 483         CVAL(cli->outbuf,smb_com) = SMBlockingX;
 484         SSVAL(cli->outbuf,smb_tid,cli->cnum);
 485         cli_setup_packet(cli);
 486
 487         CVAL(cli->outbuf,smb_vwv0) = 0xFF;
 488         SSVAL(cli->outbuf,smb_vwv2,fnum);
 489         CVAL(cli->outbuf,smb_vwv3) = ltype;
 490         SIVALS(cli->outbuf, smb_vwv4, timeout);
 491         SSVAL(cli->outbuf,smb_vwv6,0);
 492         SSVAL(cli->outbuf,smb_vwv7,1);
 493
 494         p = smb_buf(cli->outbuf);
 495         SIVAL(p, 0, cli->pid);
 496         SIVAL(p, 4, (offset>>32));
 497         SIVAL(p, 8, (offset&0xffffffff));
 498         SIVAL(p, 12, (len>>32));
 499         SIVAL(p, 16, (len&0xffffffff));
 500         cli_send_smb(cli);
 501
 502         cli->timeout = (timeout == -1) ? 0x7FFFFFFF : (timeout + 2*1000);
 503
 504         if (!cli_receive_smb(cli)) {
 505                 cli->timeout = saved_timeout;
 506                 return False;
 507         }
 508
 509         cli->timeout = saved_timeout;
 510
 511         if (CVAL(cli->inbuf,smb_rcls) != 0) {
 512                 return False;
 513         }
 514
 515         return True;
 516 }
 517
 518 /****************************************************************************
 519   unlock a file with 64 bit offsets
 520 ****************************************************************************/
 521 BOOL cli_unlock64(struct cli_state *cli, int fnum, SMB_BIG_UINT offset, SMB_BIG_UINT len)
 522 {
 523         char *p;
 524
 525         memset(cli->outbuf,'\0',smb_size);
 526         memset(cli->inbuf,'\0',smb_size);
 527
 528         set_message(cli->outbuf,8,20,True);
 529
 530         CVAL(cli->outbuf,smb_com) = SMBlockingX;
 531         SSVAL(cli->outbuf,smb_tid,cli->cnum);
 532         cli_setup_packet(cli);
 533
 534         CVAL(cli->outbuf,smb_vwv0) = 0xFF;
 535         SSVAL(cli->outbuf,smb_vwv2,fnum);
 536         CVAL(cli->outbuf,smb_vwv3) = LOCKING_ANDX_LARGE_FILES;
 537         SIVALS(cli->outbuf, smb_vwv4, 0);
 538         SSVAL(cli->outbuf,smb_vwv6,1);
 539         SSVAL(cli->outbuf,smb_vwv7,0);
 540
 541         p = smb_buf(cli->outbuf);
 542         SIVAL(p, 0, cli->pid);
 543         SIVAL(p, 4, (offset>>32));
 544         SIVAL(p, 8, (offset&0xffffffff));
 545         SIVAL(p, 12, (len>>32));
 546         SIVAL(p, 16, (len&0xffffffff));
 547
 548         cli_send_smb(cli);
 549         if (!cli_receive_smb(cli)) {
 550                 return False;
 551         }
 552
 553         if (CVAL(cli->inbuf,smb_rcls) != 0) {
 554                 return False;
 555         }
 556
 557         return True;
 558 }
 559
 560
 561
 562
 563
 564 /****************************************************************************
 565 do a SMBgetattrE call
 566 ****************************************************************************/
 567 BOOL cli_getattrE(struct cli_state *cli, int fd,
 568                   uint16 *attr, size_t *size,
 569                   time_t *c_time, time_t *a_time, time_t *m_time)
 570 {
 571         memset(cli->outbuf,'\0',smb_size);
 572         memset(cli->inbuf,'\0',smb_size);
 573
 574         set_message(cli->outbuf,1,0,True);
 575
 576         CVAL(cli->outbuf,smb_com) = SMBgetattrE;
 577         SSVAL(cli->outbuf,smb_tid,cli->cnum);
 578         cli_setup_packet(cli);
 579
 580         SSVAL(cli->outbuf,smb_vwv0,fd);
 581
 582         cli_send_smb(cli);
 583         if (!cli_receive_smb(cli)) {
 584                 return False;
 585         }
 586
 587         if (CVAL(cli->inbuf,smb_rcls) != 0) {
 588                 return False;
 589         }
 590
 591         if (size) {
 592                 *size = IVAL(cli->inbuf, smb_vwv6);
 593         }
 594
 595         if (attr) {
 596                 *attr = SVAL(cli->inbuf,smb_vwv10);
 597         }
 598
 599         if (c_time) {
 600                 *c_time = make_unix_date3(cli->inbuf+smb_vwv0);
 601         }
 602
 603         if (a_time) {
 604                 *a_time = make_unix_date3(cli->inbuf+smb_vwv2);
 605         }
 606
 607         if (m_time) {
 608                 *m_time = make_unix_date3(cli->inbuf+smb_vwv4);
 609         }
 610
 611         return True;
 612 }
 613
 614
 615 /****************************************************************************
 616 do a SMBgetatr call
 617 ****************************************************************************/
 618 BOOL cli_getatr(struct cli_state *cli, char *fname,
 619                 uint16 *attr, size_t *size, time_t *t)
 620 {
 621         char *p;
 622
 623         memset(cli->outbuf,'\0',smb_size);
 624         memset(cli->inbuf,'\0',smb_size);
 625
 626         set_message(cli->outbuf,0,0,True);
 627
 628         CVAL(cli->outbuf,smb_com) = SMBgetatr;
 629         SSVAL(cli->outbuf,smb_tid,cli->cnum);
 630         cli_setup_packet(cli);
 631
 632         p = smb_buf(cli->outbuf);
 633         *p++ = 4;
 634         p += clistr_push(cli, p, fname, -1, CLISTR_TERMINATE | CLISTR_CONVERT);
 635
 636         cli_setup_bcc(cli, p);
 637
 638         cli_send_smb(cli);
 639         if (!cli_receive_smb(cli)) {
 640                 return False;
 641         }
 642
 643         if (CVAL(cli->inbuf,smb_rcls) != 0) {
 644                 return False;
 645         }
 646
 647         if (size) {
 648                 *size = IVAL(cli->inbuf, smb_vwv3);
 649         }
 650
 651         if (t) {
 652                 *t = make_unix_date3(cli->inbuf+smb_vwv1);
 653         }
 654
 655         if (attr) {
 656                 *attr = SVAL(cli->inbuf,smb_vwv0);
 657         }
 658
 659
 660         return True;
 661 }
 662
 663
 664 /****************************************************************************
 665 do a SMBsetatr call
 666 ****************************************************************************/
 667 BOOL cli_setatr(struct cli_state *cli, char *fname, uint16 attr, time_t t)
 668 {
 669         char *p;
 670
 671         memset(cli->outbuf,'\0',smb_size);
 672         memset(cli->inbuf,'\0',smb_size);
 673
 674         set_message(cli->outbuf,8,strlen(fname)+4,True);
 675
 676         CVAL(cli->outbuf,smb_com) = SMBsetatr;
 677         SSVAL(cli->outbuf,smb_tid,cli->cnum);
 678         cli_setup_packet(cli);
 679
 680         SSVAL(cli->outbuf,smb_vwv0, attr);
 681         put_dos_date3(cli->outbuf,smb_vwv1, t);
 682
 683         p = smb_buf(cli->outbuf);
 684         *p = 4;
 685         pstrcpy(p+1, fname);
 686         unix_to_dos(p+1,True);
 687         p = skip_string(p,1);
 688         *p = 4;
 689
 690         cli_send_smb(cli);
 691         if (!cli_receive_smb(cli)) {
 692                 return False;
 693         }
 694
 695         if (CVAL(cli->inbuf,smb_rcls) != 0) {
 696                 return False;
 697         }
 698
 699         return True;
 700 }
 701
 702
 703 /****************************************************************************
 704 check for existance of a dir
 705 ****************************************************************************/
 706 BOOL cli_chkpath(struct cli_state *cli, char *path)
 707 {
 708         pstring path2;
 709         char *p;
 710
 711         safe_strcpy(path2,path,sizeof(pstring));
 712         trim_string(path2,NULL,"\\");
 713         if (!*path2) *path2 = '\\';
 714
 715         memset(cli->outbuf,'\0',smb_size);
 716         set_message(cli->outbuf,0,0,True);
 717         SCVAL(cli->outbuf,smb_com,SMBchkpth);
 718         SSVAL(cli->outbuf,smb_tid,cli->cnum);
 719         cli_setup_packet(cli);
 720         p = smb_buf(cli->outbuf);
 721         *p++ = 4;
 722         p += clistr_push(cli, p, path2, -1, CLISTR_TERMINATE | CLISTR_CONVERT);
 723
 724         cli_setup_bcc(cli, p);
 725
 726         cli_send_smb(cli);
 727         if (!cli_receive_smb(cli)) {
 728                 return False;
 729         }
 730
 731         if (cli_error(cli, NULL, NULL, NULL)) return False;
 732
 733         return True;
 734 }
 735
 736
 737
 738 /****************************************************************************
 739 query disk space
 740 ****************************************************************************/
 741 BOOL cli_dskattr(struct cli_state *cli, int *bsize, int *total, int *avail)
 742 {
 743         memset(cli->outbuf,'\0',smb_size);
 744         set_message(cli->outbuf,0,0,True);
 745         CVAL(cli->outbuf,smb_com) = SMBdskattr;
 746         SSVAL(cli->outbuf,smb_tid,cli->cnum);
 747         cli_setup_packet(cli);
 748
 749         cli_send_smb(cli);
 750         if (!cli_receive_smb(cli)) {
 751                 return False;
 752         }
 753
 754         *bsize = SVAL(cli->inbuf,smb_vwv1)*SVAL(cli->inbuf,smb_vwv2);
 755         *total = SVAL(cli->inbuf,smb_vwv0);
 756         *avail = SVAL(cli->inbuf,smb_vwv3);
 757
 758         return True;
 759 }
 760