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