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