source3/libsmb/clifile.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    client file operations
   4    Copyright (C) Andrew Tridgell 1994-1998
   5    Copyright (C) Jeremy Allison 2001-2002
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 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  Hard/Symlink a file (UNIX extensions).
  28  Creates new name (sym)linked to oldname.
  29 ****************************************************************************/
  30
  31 static BOOL cli_link_internal(struct cli_state *cli, const char *oldname, const char *newname, BOOL hard_link)
  32 {
  33         unsigned int data_len = 0;
  34         unsigned 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         size_t oldlen = 2*(strlen(oldname)+1);
  41         size_t newlen = 2*(strlen(newname)+1);
  42
  43         memset(param, 0, sizeof(param));
  44         SSVAL(param,0,hard_link ? SMB_SET_FILE_UNIX_HLINK : SMB_SET_FILE_UNIX_LINK);
  45         p = &param[6];
  46
  47         p += clistr_push(cli, p, newname, MIN(newlen, sizeof(param)-6), STR_TERMINATE);
  48         param_len = PTR_DIFF(p, param);
  49
  50         p = data;
  51         p += clistr_push(cli, p, oldname, MIN(oldlen,sizeof(data)), STR_TERMINATE);
  52         data_len = PTR_DIFF(p, data);
  53
  54         if (!cli_send_trans(cli, SMBtrans2,
  55                 NULL,                        /* name */
  56                 -1, 0,                          /* fid, flags */
  57                 &setup, 1, 0,                   /* setup, length, max */
  58                 param, param_len, 2,            /* param, length, max */
  59                 (char *)&data,  data_len, cli->max_xmit /* data, length, max */
  60                 )) {
  61                         return False;
  62         }
  63
  64         if (!cli_receive_trans(cli, SMBtrans2,
  65                 &rparam, &param_len,
  66                 &rdata, &data_len)) {
  67                         return False;
  68         }
  69
  70         SAFE_FREE(rdata);
  71         SAFE_FREE(rparam);
  72
  73         return True;
  74 }
  75
  76 /****************************************************************************
  77  Map standard UNIX permissions onto wire representations.
  78 ****************************************************************************/
  79
  80 uint32 unix_perms_to_wire(mode_t perms)
  81 {
  82         unsigned int ret = 0;
  83
  84         ret |= ((perms & S_IXOTH) ?  UNIX_X_OTH : 0);
  85         ret |= ((perms & S_IWOTH) ?  UNIX_W_OTH : 0);
  86         ret |= ((perms & S_IROTH) ?  UNIX_R_OTH : 0);
  87         ret |= ((perms & S_IXGRP) ?  UNIX_X_GRP : 0);
  88         ret |= ((perms & S_IWGRP) ?  UNIX_W_GRP : 0);
  89         ret |= ((perms & S_IRGRP) ?  UNIX_R_GRP : 0);
  90         ret |= ((perms & S_IXUSR) ?  UNIX_X_USR : 0);
  91         ret |= ((perms & S_IWUSR) ?  UNIX_W_USR : 0);
  92         ret |= ((perms & S_IRUSR) ?  UNIX_R_USR : 0);
  93 #ifdef S_ISVTX
  94         ret |= ((perms & S_ISVTX) ?  UNIX_STICKY : 0);
  95 #endif
  96 #ifdef S_ISGID
  97         ret |= ((perms & S_ISGID) ?  UNIX_SET_GID : 0);
  98 #endif
  99 #ifdef S_ISUID
 100         ret |= ((perms & S_ISUID) ?  UNIX_SET_UID : 0);
 101 #endif
 102         return ret;
 103 }
 104
 105 /****************************************************************************
 106  Map wire permissions to standard UNIX.
 107 ****************************************************************************/
 108
 109 mode_t wire_perms_to_unix(uint32 perms)
 110 {
 111         mode_t ret = (mode_t)0;
 112
 113         ret |= ((perms & UNIX_X_OTH) ? S_IXOTH : 0);
 114         ret |= ((perms & UNIX_W_OTH) ? S_IWOTH : 0);
 115         ret |= ((perms & UNIX_R_OTH) ? S_IROTH : 0);
 116         ret |= ((perms & UNIX_X_GRP) ? S_IXGRP : 0);
 117         ret |= ((perms & UNIX_W_GRP) ? S_IWGRP : 0);
 118         ret |= ((perms & UNIX_R_GRP) ? S_IRGRP : 0);
 119         ret |= ((perms & UNIX_X_USR) ? S_IXUSR : 0);
 120         ret |= ((perms & UNIX_W_USR) ? S_IWUSR : 0);
 121         ret |= ((perms & UNIX_R_USR) ? S_IRUSR : 0);
 122 #ifdef S_ISVTX
 123         ret |= ((perms & UNIX_STICKY) ? S_ISVTX : 0);
 124 #endif
 125 #ifdef S_ISGID
 126         ret |= ((perms & UNIX_SET_GID) ? S_ISGID : 0);
 127 #endif
 128 #ifdef S_ISUID
 129         ret |= ((perms & UNIX_SET_UID) ? S_ISUID : 0);
 130 #endif
 131         return ret;
 132 }
 133
 134 /****************************************************************************
 135  Return the file type from the wire filetype for UNIX extensions.
 136 ****************************************************************************/
 137
 138 static mode_t unix_filetype_from_wire(uint32 wire_type)
 139 {
 140         switch (wire_type) {
 141                 case UNIX_TYPE_FILE:
 142                         return S_IFREG;
 143                 case UNIX_TYPE_DIR:
 144                         return S_IFDIR;
 145 #ifdef S_IFLNK
 146                 case UNIX_TYPE_SYMLINK:
 147                         return S_IFLNK;
 148 #endif
 149 #ifdef S_IFCHR
 150                 case UNIX_TYPE_CHARDEV:
 151                         return S_IFCHR;
 152 #endif
 153 #ifdef S_IFBLK
 154                 case UNIX_TYPE_BLKDEV:
 155                         return S_IFBLK;
 156 #endif
 157 #ifdef S_IFIFO
 158                 case UNIX_TYPE_FIFO:
 159                         return S_IFIFO;
 160 #endif
 161 #ifdef S_IFSOCK
 162                 case UNIX_TYPE_SOCKET:
 163                         return S_IFSOCK;
 164 #endif
 165                 default:
 166                         return (mode_t)0;
 167         }
 168 }
 169
 170 /****************************************************************************
 171  Stat a file (UNIX extensions).
 172 ****************************************************************************/
 173
 174 BOOL cli_unix_stat(struct cli_state *cli, const char *name, SMB_STRUCT_STAT *sbuf)
 175 {
 176         unsigned int param_len = 0;
 177         unsigned int data_len = 0;
 178         uint16 setup = TRANSACT2_QPATHINFO;
 179         char param[sizeof(pstring)+6];
 180         char *rparam=NULL, *rdata=NULL;
 181         char *p;
 182
 183         ZERO_STRUCTP(sbuf);
 184
 185         p = param;
 186         memset(p, 0, 6);
 187         SSVAL(p, 0, SMB_QUERY_FILE_UNIX_BASIC);
 188         p += 6;
 189         p += clistr_push(cli, p, name, sizeof(pstring)-6, STR_TERMINATE);
 190         param_len = PTR_DIFF(p, param);
 191
 192         if (!cli_send_trans(cli, SMBtrans2,
 193                 NULL,                        /* name */
 194                 -1, 0,                       /* fid, flags */
 195                 &setup, 1, 0,                /* setup, length, max */
 196                 param, param_len, 2,         /* param, length, max */
 197                 NULL,  0, cli->max_xmit      /* data, length, max */
 198                 )) {
 199                         return False;
 200         }
 201
 202         if (!cli_receive_trans(cli, SMBtrans2,
 203                 &rparam, &param_len,
 204                 &rdata, &data_len)) {
 205                         return False;
 206         }
 207
 208         sbuf->st_size = IVAL2_TO_SMB_BIG_UINT(rdata,0);     /* total size, in bytes */
 209         sbuf->st_blocks = IVAL2_TO_SMB_BIG_UINT(rdata,8);   /* number of blocks allocated */
 210         sbuf->st_blocks /= STAT_ST_BLOCKSIZE;
 211         sbuf->st_ctime = interpret_long_date(rdata + 16);    /* time of last change */
 212         sbuf->st_atime = interpret_long_date(rdata + 24);    /* time of last access */
 213         sbuf->st_mtime = interpret_long_date(rdata + 32);    /* time of last modification */
 214         sbuf->st_uid = IVAL(rdata,40);      /* user ID of owner */
 215         sbuf->st_gid = IVAL(rdata,48);      /* group ID of owner */
 216         sbuf->st_mode |= unix_filetype_from_wire(IVAL(rdata, 56));
 217 #if defined(HAVE_MAKEDEV)
 218         {
 219                 uint32 dev_major = IVAL(rdata,60);
 220                 uint32 dev_minor = IVAL(rdata,68);
 221                 sbuf->st_rdev = makedev(dev_major, dev_minor);
 222         }
 223 #endif
 224         sbuf->st_ino = (SMB_INO_T)IVAL2_TO_SMB_BIG_UINT(rdata,76);      /* inode */
 225         sbuf->st_mode |= wire_perms_to_unix(IVAL(rdata,84));     /* protection */
 226         sbuf->st_nlink = IVAL(rdata,92);    /* number of hard links */
 227
 228         SAFE_FREE(rdata);
 229         SAFE_FREE(rparam);
 230
 231         return True;
 232 }
 233
 234 /****************************************************************************
 235  Symlink a file (UNIX extensions).
 236 ****************************************************************************/
 237
 238 BOOL cli_unix_symlink(struct cli_state *cli, const char *oldname, const char *newname)
 239 {
 240         return cli_link_internal(cli, oldname, newname, False);
 241 }
 242
 243 /****************************************************************************
 244  Hard a file (UNIX extensions).
 245 ****************************************************************************/
 246
 247 BOOL cli_unix_hardlink(struct cli_state *cli, const char *oldname, const char *newname)
 248 {
 249         return cli_link_internal(cli, oldname, newname, True);
 250 }
 251
 252 /****************************************************************************
 253  Chmod or chown a file internal (UNIX extensions).
 254 ****************************************************************************/
 255
 256 static BOOL cli_unix_chmod_chown_internal(struct cli_state *cli, const char *fname, uint32 mode, uint32 uid, uint32 gid)
 257 {
 258         unsigned int data_len = 0;
 259         unsigned int param_len = 0;
 260         uint16 setup = TRANSACT2_SETPATHINFO;
 261         char param[sizeof(pstring)+6];
 262         char data[100];
 263         char *rparam=NULL, *rdata=NULL;
 264         char *p;
 265
 266         memset(param, 0, sizeof(param));
 267         memset(data, 0, sizeof(data));
 268         SSVAL(param,0,SMB_SET_FILE_UNIX_BASIC);
 269         p = &param[6];
 270
 271         p += clistr_push(cli, p, fname, -1, STR_TERMINATE);
 272         param_len = PTR_DIFF(p, param);
 273
 274         SIVAL(data,40,uid);
 275         SIVAL(data,48,gid);
 276         SIVAL(data,84,mode);
 277
 278         data_len = 100;
 279
 280         if (!cli_send_trans(cli, SMBtrans2,
 281                 NULL,                        /* name */
 282                 -1, 0,                          /* fid, flags */
 283                 &setup, 1, 0,                   /* setup, length, max */
 284                 param, param_len, 2,            /* param, length, max */
 285                 (char *)&data,  data_len, cli->max_xmit /* data, length, max */
 286                 )) {
 287                         return False;
 288         }
 289
 290         if (!cli_receive_trans(cli, SMBtrans2,
 291                 &rparam, &param_len,
 292                 &rdata, &data_len)) {
 293                         return False;
 294         }
 295
 296         SAFE_FREE(rdata);
 297         SAFE_FREE(rparam);
 298
 299         return True;
 300 }
 301
 302 /****************************************************************************
 303  chmod a file (UNIX extensions).
 304 ****************************************************************************/
 305
 306 BOOL cli_unix_chmod(struct cli_state *cli, const char *fname, mode_t mode)
 307 {
 308         return cli_unix_chmod_chown_internal(cli, fname,
 309                 unix_perms_to_wire(mode), SMB_UID_NO_CHANGE, SMB_GID_NO_CHANGE);
 310 }
 311
 312 /****************************************************************************
 313  chown a file (UNIX extensions).
 314 ****************************************************************************/
 315
 316 BOOL cli_unix_chown(struct cli_state *cli, const char *fname, uid_t uid, gid_t gid)
 317 {
 318         return cli_unix_chmod_chown_internal(cli, fname, SMB_MODE_NO_CHANGE, (uint32)uid, (uint32)gid);
 319 }
 320
 321 /****************************************************************************
 322  Rename a file.
 323 ****************************************************************************/
 324
 325 BOOL cli_rename(struct cli_state *cli, const char *fname_src, const char *fname_dst)
 326 {
 327         char *p;
 328
 329         memset(cli->outbuf,'\0',smb_size);
 330         memset(cli->inbuf,'\0',smb_size);
 331
 332         set_message(cli->outbuf,1, 0, True);
 333
 334         SCVAL(cli->outbuf,smb_com,SMBmv);
 335         SSVAL(cli->outbuf,smb_tid,cli->cnum);
 336         cli_setup_packet(cli);
 337
 338         SSVAL(cli->outbuf,smb_vwv0,aSYSTEM | aHIDDEN | aDIR);
 339
 340         p = smb_buf(cli->outbuf);
 341         *p++ = 4;
 342         p += clistr_push(cli, p, fname_src, -1, STR_TERMINATE);
 343         *p++ = 4;
 344         p += clistr_push(cli, p, fname_dst, -1, STR_TERMINATE);
 345
 346         cli_setup_bcc(cli, p);
 347
 348         cli_send_smb(cli);
 349         if (!cli_receive_smb(cli))
 350                 return False;
 351
 352         if (cli_is_error(cli))
 353                 return False;
 354
 355         return True;
 356 }
 357
 358 /****************************************************************************
 359  NT Rename a file.
 360 ****************************************************************************/
 361
 362 BOOL cli_ntrename(struct cli_state *cli, const char *fname_src, const char *fname_dst)
 363 {
 364         char *p;
 365
 366         memset(cli->outbuf,'\0',smb_size);
 367         memset(cli->inbuf,'\0',smb_size);
 368
 369         set_message(cli->outbuf, 4, 0, True);
 370
 371         SCVAL(cli->outbuf,smb_com,SMBntrename);
 372         SSVAL(cli->outbuf,smb_tid,cli->cnum);
 373         cli_setup_packet(cli);
 374
 375         SSVAL(cli->outbuf,smb_vwv0,aSYSTEM | aHIDDEN | aDIR);
 376         SSVAL(cli->outbuf,smb_vwv1, RENAME_FLAG_RENAME);
 377
 378         p = smb_buf(cli->outbuf);
 379         *p++ = 4;
 380         p += clistr_push(cli, p, fname_src, -1, STR_TERMINATE);
 381         *p++ = 4;
 382         p += clistr_push(cli, p, fname_dst, -1, STR_TERMINATE);
 383
 384         cli_setup_bcc(cli, p);
 385
 386         cli_send_smb(cli);
 387         if (!cli_receive_smb(cli))
 388                 return False;
 389
 390         if (cli_is_error(cli))
 391                 return False;
 392
 393         return True;
 394 }
 395
 396 /****************************************************************************
 397  NT hardlink a file.
 398 ****************************************************************************/
 399
 400 BOOL cli_nt_hardlink(struct cli_state *cli, const char *fname_src, const char *fname_dst)
 401 {
 402         char *p;
 403
 404         memset(cli->outbuf,'\0',smb_size);
 405         memset(cli->inbuf,'\0',smb_size);
 406
 407         set_message(cli->outbuf, 4, 0, True);
 408
 409         SCVAL(cli->outbuf,smb_com,SMBntrename);
 410         SSVAL(cli->outbuf,smb_tid,cli->cnum);
 411         cli_setup_packet(cli);
 412
 413         SSVAL(cli->outbuf,smb_vwv0,aSYSTEM | aHIDDEN | aDIR);
 414         SSVAL(cli->outbuf,smb_vwv1, RENAME_FLAG_HARD_LINK);
 415
 416         p = smb_buf(cli->outbuf);
 417         *p++ = 4;
 418         p += clistr_push(cli, p, fname_src, -1, STR_TERMINATE);
 419         *p++ = 4;
 420         p += clistr_push(cli, p, fname_dst, -1, STR_TERMINATE);
 421
 422         cli_setup_bcc(cli, p);
 423
 424         cli_send_smb(cli);
 425         if (!cli_receive_smb(cli))
 426                 return False;
 427
 428         if (cli_is_error(cli))
 429                 return False;
 430
 431         return True;
 432 }
 433
 434 /****************************************************************************
 435  Delete a file.
 436 ****************************************************************************/
 437
 438 BOOL cli_unlink(struct cli_state *cli, const char *fname)
 439 {
 440         char *p;
 441
 442         memset(cli->outbuf,'\0',smb_size);
 443         memset(cli->inbuf,'\0',smb_size);
 444
 445         set_message(cli->outbuf,1, 0,True);
 446
 447         SCVAL(cli->outbuf,smb_com,SMBunlink);
 448         SSVAL(cli->outbuf,smb_tid,cli->cnum);
 449         cli_setup_packet(cli);
 450
 451         SSVAL(cli->outbuf,smb_vwv0,aSYSTEM | aHIDDEN);
 452
 453         p = smb_buf(cli->outbuf);
 454         *p++ = 4;
 455         p += clistr_push(cli, p, fname, -1, STR_TERMINATE);
 456
 457         cli_setup_bcc(cli, p);
 458         cli_send_smb(cli);
 459         if (!cli_receive_smb(cli)) {
 460                 return False;
 461         }
 462
 463         if (cli_is_error(cli)) {
 464                 return False;
 465         }
 466
 467         return True;
 468 }
 469
 470 /****************************************************************************
 471  Create a directory.
 472 ****************************************************************************/
 473
 474 BOOL cli_mkdir(struct cli_state *cli, const char *dname)
 475 {
 476         char *p;
 477
 478         memset(cli->outbuf,'\0',smb_size);
 479         memset(cli->inbuf,'\0',smb_size);
 480
 481         set_message(cli->outbuf,0, 0,True);
 482
 483         SCVAL(cli->outbuf,smb_com,SMBmkdir);
 484         SSVAL(cli->outbuf,smb_tid,cli->cnum);
 485         cli_setup_packet(cli);
 486
 487         p = smb_buf(cli->outbuf);
 488         *p++ = 4;
 489         p += clistr_push(cli, p, dname, -1, STR_TERMINATE);
 490
 491         cli_setup_bcc(cli, p);
 492
 493         cli_send_smb(cli);
 494         if (!cli_receive_smb(cli)) {
 495                 return False;
 496         }
 497
 498         if (cli_is_error(cli)) {
 499                 return False;
 500         }
 501
 502         return True;
 503 }
 504
 505 /****************************************************************************
 506  Remove a directory.
 507 ****************************************************************************/
 508
 509 BOOL cli_rmdir(struct cli_state *cli, const char *dname)
 510 {
 511         char *p;
 512
 513         memset(cli->outbuf,'\0',smb_size);
 514         memset(cli->inbuf,'\0',smb_size);
 515
 516         set_message(cli->outbuf,0, 0, True);
 517
 518         SCVAL(cli->outbuf,smb_com,SMBrmdir);
 519         SSVAL(cli->outbuf,smb_tid,cli->cnum);
 520         cli_setup_packet(cli);
 521
 522         p = smb_buf(cli->outbuf);
 523         *p++ = 4;
 524         p += clistr_push(cli, p, dname, -1, STR_TERMINATE);
 525
 526         cli_setup_bcc(cli, p);
 527
 528         cli_send_smb(cli);
 529         if (!cli_receive_smb(cli)) {
 530                 return False;
 531         }
 532
 533         if (cli_is_error(cli)) {
 534                 return False;
 535         }
 536
 537         return True;
 538 }
 539
 540 /****************************************************************************
 541  Set or clear the delete on close flag.
 542 ****************************************************************************/
 543
 544 int cli_nt_delete_on_close(struct cli_state *cli, int fnum, BOOL flag)
 545 {
 546         unsigned int data_len = 1;
 547         unsigned int param_len = 6;
 548         uint16 setup = TRANSACT2_SETFILEINFO;
 549         pstring param;
 550         unsigned char data;
 551         char *rparam=NULL, *rdata=NULL;
 552
 553         memset(param, 0, param_len);
 554         SSVAL(param,0,fnum);
 555         SSVAL(param,2,SMB_SET_FILE_DISPOSITION_INFO);
 556
 557         data = flag ? 1 : 0;
 558
 559         if (!cli_send_trans(cli, SMBtrans2,
 560                                                 NULL,                        /* name */
 561                                                 -1, 0,                          /* fid, flags */
 562                                                 &setup, 1, 0,                   /* setup, length, max */
 563                                                 param, param_len, 2,            /* param, length, max */
 564                                                 (char *)&data,  data_len, cli->max_xmit /* data, length, max */
 565                                                 )) {
 566                 return False;
 567         }
 568
 569         if (!cli_receive_trans(cli, SMBtrans2,
 570                                                 &rparam, &param_len,
 571                                                 &rdata, &data_len)) {
 572                 return False;
 573         }
 574
 575         SAFE_FREE(rdata);
 576         SAFE_FREE(rparam);
 577
 578         return True;
 579 }
 580
 581 /****************************************************************************
 582  Open a file - exposing the full horror of the NT API :-).
 583  Used in smbtorture.
 584 ****************************************************************************/
 585
 586 int cli_nt_create_full(struct cli_state *cli, const char *fname,
 587                  uint32 CreatFlags, uint32 DesiredAccess,
 588                  uint32 FileAttributes, uint32 ShareAccess,
 589                  uint32 CreateDisposition, uint32 CreateOptions,
 590                  uint8 SecuityFlags)
 591 {
 592         char *p;
 593         int len;
 594
 595         memset(cli->outbuf,'\0',smb_size);
 596         memset(cli->inbuf,'\0',smb_size);
 597
 598         set_message(cli->outbuf,24,0,True);
 599
 600         SCVAL(cli->outbuf,smb_com,SMBntcreateX);
 601         SSVAL(cli->outbuf,smb_tid,cli->cnum);
 602         cli_setup_packet(cli);
 603
 604         SSVAL(cli->outbuf,smb_vwv0,0xFF);
 605         if (cli->use_oplocks)
 606                 CreatFlags |= (REQUEST_OPLOCK|REQUEST_BATCH_OPLOCK);
 607
 608         SIVAL(cli->outbuf,smb_ntcreate_Flags, CreatFlags);
 609         SIVAL(cli->outbuf,smb_ntcreate_RootDirectoryFid, 0x0);
 610         SIVAL(cli->outbuf,smb_ntcreate_DesiredAccess, DesiredAccess);
 611         SIVAL(cli->outbuf,smb_ntcreate_FileAttributes, FileAttributes);
 612         SIVAL(cli->outbuf,smb_ntcreate_ShareAccess, ShareAccess);
 613         SIVAL(cli->outbuf,smb_ntcreate_CreateDisposition, CreateDisposition);
 614         SIVAL(cli->outbuf,smb_ntcreate_CreateOptions, CreateOptions);
 615         SIVAL(cli->outbuf,smb_ntcreate_ImpersonationLevel, 0x02);
 616         SCVAL(cli->outbuf,smb_ntcreate_SecurityFlags, SecuityFlags);
 617
 618         p = smb_buf(cli->outbuf);
 619         /* this alignment and termination is critical for netapp filers. Don't change */
 620         p += clistr_align_out(cli, p, 0);
 621         len = clistr_push(cli, p, fname, -1, 0);
 622         p += len;
 623         SSVAL(cli->outbuf,smb_ntcreate_NameLength, len);
 624         /* sigh. this copes with broken netapp filer behaviour */
 625         p += clistr_push(cli, p, "", -1, STR_TERMINATE);
 626
 627         cli_setup_bcc(cli, p);
 628
 629         cli_send_smb(cli);
 630         if (!cli_receive_smb(cli)) {
 631                 return -1;
 632         }
 633
 634         if (cli_is_error(cli)) {
 635                 return -1;
 636         }
 637
 638         return SVAL(cli->inbuf,smb_vwv2 + 1);
 639 }
 640
 641 /****************************************************************************
 642  Open a file.
 643 ****************************************************************************/
 644
 645 int cli_nt_create(struct cli_state *cli, const char *fname, uint32 DesiredAccess)
 646 {
 647         return cli_nt_create_full(cli, fname, 0, DesiredAccess, 0,
 648                                 FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_EXISTS_OPEN, 0x0, 0x0);
 649 }
 650
 651 /****************************************************************************
 652  Open a file
 653  WARNING: if you open with O_WRONLY then getattrE won't work!
 654 ****************************************************************************/
 655
 656 int cli_open(struct cli_state *cli, const char *fname, int flags, int share_mode)
 657 {
 658         char *p;
 659         unsigned openfn=0;
 660         unsigned accessmode=0;
 661
 662         if (flags & O_CREAT)
 663                 openfn |= (1<<4);
 664         if (!(flags & O_EXCL)) {
 665                 if (flags & O_TRUNC)
 666                         openfn |= (1<<1);
 667                 else
 668                         openfn |= (1<<0);
 669         }
 670
 671         accessmode = (share_mode<<4);
 672
 673         if ((flags & O_ACCMODE) == O_RDWR) {
 674                 accessmode |= 2;
 675         } else if ((flags & O_ACCMODE) == O_WRONLY) {
 676                 accessmode |= 1;
 677         }
 678
 679 #if defined(O_SYNC)
 680         if ((flags & O_SYNC) == O_SYNC) {
 681                 accessmode |= (1<<14);
 682         }
 683 #endif /* O_SYNC */
 684
 685         if (share_mode == DENY_FCB) {
 686                 accessmode = 0xFF;
 687         }
 688
 689         memset(cli->outbuf,'\0',smb_size);
 690         memset(cli->inbuf,'\0',smb_size);
 691
 692         set_message(cli->outbuf,15,0,True);
 693
 694         SCVAL(cli->outbuf,smb_com,SMBopenX);
 695         SSVAL(cli->outbuf,smb_tid,cli->cnum);
 696         cli_setup_packet(cli);
 697
 698         SSVAL(cli->outbuf,smb_vwv0,0xFF);
 699         SSVAL(cli->outbuf,smb_vwv2,0);  /* no additional info */
 700         SSVAL(cli->outbuf,smb_vwv3,accessmode);
 701         SSVAL(cli->outbuf,smb_vwv4,aSYSTEM | aHIDDEN);
 702         SSVAL(cli->outbuf,smb_vwv5,0);
 703         SSVAL(cli->outbuf,smb_vwv8,openfn);
 704
 705         if (cli->use_oplocks) {
 706                 /* if using oplocks then ask for a batch oplock via
 707                    core and extended methods */
 708                 SCVAL(cli->outbuf,smb_flg, CVAL(cli->outbuf,smb_flg)|
 709                         FLAG_REQUEST_OPLOCK|FLAG_REQUEST_BATCH_OPLOCK);
 710                 SSVAL(cli->outbuf,smb_vwv2,SVAL(cli->outbuf,smb_vwv2) | 6);
 711         }
 712
 713         p = smb_buf(cli->outbuf);
 714         p += clistr_push(cli, p, fname, -1, STR_TERMINATE);
 715
 716         cli_setup_bcc(cli, p);
 717
 718         cli_send_smb(cli);
 719         if (!cli_receive_smb(cli)) {
 720                 return -1;
 721         }
 722
 723         if (cli_is_error(cli)) {
 724                 return -1;
 725         }
 726
 727         return SVAL(cli->inbuf,smb_vwv2);
 728 }
 729
 730 /****************************************************************************
 731  Close a file.
 732 ****************************************************************************/
 733
 734 BOOL cli_close(struct cli_state *cli, int fnum)
 735 {
 736         memset(cli->outbuf,'\0',smb_size);
 737         memset(cli->inbuf,'\0',smb_size);
 738
 739         set_message(cli->outbuf,3,0,True);
 740
 741         SCVAL(cli->outbuf,smb_com,SMBclose);
 742         SSVAL(cli->outbuf,smb_tid,cli->cnum);
 743         cli_setup_packet(cli);
 744
 745         SSVAL(cli->outbuf,smb_vwv0,fnum);
 746         SIVALS(cli->outbuf,smb_vwv1,-1);
 747
 748         cli_send_smb(cli);
 749         if (!cli_receive_smb(cli)) {
 750                 return False;
 751         }
 752
 753         return !cli_is_error(cli);
 754 }
 755
 756
 757 /****************************************************************************
 758  send a lock with a specified locktype
 759  this is used for testing LOCKING_ANDX_CANCEL_LOCK
 760 ****************************************************************************/
 761 NTSTATUS cli_locktype(struct cli_state *cli, int fnum,
 762                       uint32 offset, uint32 len, int timeout, unsigned char locktype)
 763 {
 764         char *p;
 765         int saved_timeout = cli->timeout;
 766
 767         memset(cli->outbuf,'\0',smb_size);
 768         memset(cli->inbuf,'\0', smb_size);
 769
 770         set_message(cli->outbuf,8,0,True);
 771
 772         SCVAL(cli->outbuf,smb_com,SMBlockingX);
 773         SSVAL(cli->outbuf,smb_tid,cli->cnum);
 774         cli_setup_packet(cli);
 775
 776         SCVAL(cli->outbuf,smb_vwv0,0xFF);
 777         SSVAL(cli->outbuf,smb_vwv2,fnum);
 778         SCVAL(cli->outbuf,smb_vwv3,locktype);
 779         SIVALS(cli->outbuf, smb_vwv4, timeout);
 780         SSVAL(cli->outbuf,smb_vwv6,0);
 781         SSVAL(cli->outbuf,smb_vwv7,1);
 782
 783         p = smb_buf(cli->outbuf);
 784         SSVAL(p, 0, cli->pid);
 785         SIVAL(p, 2, offset);
 786         SIVAL(p, 6, len);
 787
 788         p += 10;
 789
 790         cli_setup_bcc(cli, p);
 791
 792         cli_send_smb(cli);
 793
 794         if (timeout != 0) {
 795                 cli->timeout = (timeout == -1) ? 0x7FFFFFFF : (timeout + 2*1000);
 796         }
 797
 798         if (!cli_receive_smb(cli)) {
 799                 cli->timeout = saved_timeout;
 800                 return NT_STATUS_UNSUCCESSFUL;
 801         }
 802
 803         cli->timeout = saved_timeout;
 804
 805         return cli_nt_error(cli);
 806 }
 807
 808
 809 /****************************************************************************
 810  Lock a file.
 811  note that timeout is in units of 2 milliseconds
 812 ****************************************************************************/
 813 BOOL cli_lock(struct cli_state *cli, int fnum,
 814               uint32 offset, uint32 len, int timeout, enum brl_type lock_type)
 815 {
 816         char *p;
 817         int saved_timeout = cli->timeout;
 818
 819         memset(cli->outbuf,'\0',smb_size);
 820         memset(cli->inbuf,'\0', smb_size);
 821
 822         set_message(cli->outbuf,8,0,True);
 823
 824         SCVAL(cli->outbuf,smb_com,SMBlockingX);
 825         SSVAL(cli->outbuf,smb_tid,cli->cnum);
 826         cli_setup_packet(cli);
 827
 828         SCVAL(cli->outbuf,smb_vwv0,0xFF);
 829         SSVAL(cli->outbuf,smb_vwv2,fnum);
 830         SCVAL(cli->outbuf,smb_vwv3,(lock_type == READ_LOCK? 1 : 0));
 831         SIVALS(cli->outbuf, smb_vwv4, timeout);
 832         SSVAL(cli->outbuf,smb_vwv6,0);
 833         SSVAL(cli->outbuf,smb_vwv7,1);
 834
 835         p = smb_buf(cli->outbuf);
 836         SSVAL(p, 0, cli->pid);
 837         SIVAL(p, 2, offset);
 838         SIVAL(p, 6, len);
 839
 840         p += 10;
 841
 842         cli_setup_bcc(cli, p);
 843
 844         cli_send_smb(cli);
 845
 846         if (timeout != 0) {
 847                 cli->timeout = (timeout == -1) ? 0x7FFFFFFF : (timeout*2 + 5*1000);
 848         }
 849
 850         if (!cli_receive_smb(cli)) {
 851                 cli->timeout = saved_timeout;
 852                 return False;
 853         }
 854
 855         cli->timeout = saved_timeout;
 856
 857         if (cli_is_error(cli)) {
 858                 return False;
 859         }
 860
 861         return True;
 862 }
 863
 864 /****************************************************************************
 865  Unlock a file.
 866 ****************************************************************************/
 867
 868 BOOL cli_unlock(struct cli_state *cli, int fnum, uint32 offset, uint32 len)
 869 {
 870         char *p;
 871
 872         memset(cli->outbuf,'\0',smb_size);
 873         memset(cli->inbuf,'\0',smb_size);
 874
 875         set_message(cli->outbuf,8,0,True);
 876
 877         SCVAL(cli->outbuf,smb_com,SMBlockingX);
 878         SSVAL(cli->outbuf,smb_tid,cli->cnum);
 879         cli_setup_packet(cli);
 880
 881         SCVAL(cli->outbuf,smb_vwv0,0xFF);
 882         SSVAL(cli->outbuf,smb_vwv2,fnum);
 883         SCVAL(cli->outbuf,smb_vwv3,0);
 884         SIVALS(cli->outbuf, smb_vwv4, 0);
 885         SSVAL(cli->outbuf,smb_vwv6,1);
 886         SSVAL(cli->outbuf,smb_vwv7,0);
 887
 888         p = smb_buf(cli->outbuf);
 889         SSVAL(p, 0, cli->pid);
 890         SIVAL(p, 2, offset);
 891         SIVAL(p, 6, len);
 892         p += 10;
 893         cli_setup_bcc(cli, p);
 894         cli_send_smb(cli);
 895         if (!cli_receive_smb(cli)) {
 896                 return False;
 897         }
 898
 899         if (cli_is_error(cli)) {
 900                 return False;
 901         }
 902
 903         return True;
 904 }
 905
 906 /****************************************************************************
 907  Lock a file with 64 bit offsets.
 908 ****************************************************************************/
 909
 910 BOOL cli_lock64(struct cli_state *cli, int fnum,
 911                 SMB_BIG_UINT offset, SMB_BIG_UINT len, int timeout, enum brl_type lock_type)
 912 {
 913         char *p;
 914         int saved_timeout = cli->timeout;
 915         int ltype;
 916
 917         if (! (cli->capabilities & CAP_LARGE_FILES)) {
 918                 return cli_lock(cli, fnum, offset, len, timeout, lock_type);
 919         }
 920
 921         ltype = (lock_type == READ_LOCK? 1 : 0);
 922         ltype |= LOCKING_ANDX_LARGE_FILES;
 923
 924         memset(cli->outbuf,'\0',smb_size);
 925         memset(cli->inbuf,'\0', smb_size);
 926
 927         set_message(cli->outbuf,8,0,True);
 928
 929         SCVAL(cli->outbuf,smb_com,SMBlockingX);
 930         SSVAL(cli->outbuf,smb_tid,cli->cnum);
 931         cli_setup_packet(cli);
 932
 933         SCVAL(cli->outbuf,smb_vwv0,0xFF);
 934         SSVAL(cli->outbuf,smb_vwv2,fnum);
 935         SCVAL(cli->outbuf,smb_vwv3,ltype);
 936         SIVALS(cli->outbuf, smb_vwv4, timeout);
 937         SSVAL(cli->outbuf,smb_vwv6,0);
 938         SSVAL(cli->outbuf,smb_vwv7,1);
 939
 940         p = smb_buf(cli->outbuf);
 941         SIVAL(p, 0, cli->pid);
 942         SOFF_T_R(p, 4, offset);
 943         SOFF_T_R(p, 12, len);
 944         p += 20;
 945
 946         cli_setup_bcc(cli, p);
 947         cli_send_smb(cli);
 948
 949         if (timeout != 0) {
 950                 cli->timeout = (timeout == -1) ? 0x7FFFFFFF : (timeout + 5*1000);
 951         }
 952
 953         if (!cli_receive_smb(cli)) {
 954                 cli->timeout = saved_timeout;
 955                 return False;
 956         }
 957
 958         cli->timeout = saved_timeout;
 959
 960         if (cli_is_error(cli)) {
 961                 return False;
 962         }
 963
 964         return True;
 965 }
 966
 967 /****************************************************************************
 968  Unlock a file with 64 bit offsets.
 969 ****************************************************************************/
 970
 971 BOOL cli_unlock64(struct cli_state *cli, int fnum, SMB_BIG_UINT offset, SMB_BIG_UINT len)
 972 {
 973         char *p;
 974
 975         if (! (cli->capabilities & CAP_LARGE_FILES)) {
 976                 return cli_unlock(cli, fnum, offset, len);
 977         }
 978
 979         memset(cli->outbuf,'\0',smb_size);
 980         memset(cli->inbuf,'\0',smb_size);
 981
 982         set_message(cli->outbuf,8,0,True);
 983
 984         SCVAL(cli->outbuf,smb_com,SMBlockingX);
 985         SSVAL(cli->outbuf,smb_tid,cli->cnum);
 986         cli_setup_packet(cli);
 987
 988         SCVAL(cli->outbuf,smb_vwv0,0xFF);
 989         SSVAL(cli->outbuf,smb_vwv2,fnum);
 990         SCVAL(cli->outbuf,smb_vwv3,LOCKING_ANDX_LARGE_FILES);
 991         SIVALS(cli->outbuf, smb_vwv4, 0);
 992         SSVAL(cli->outbuf,smb_vwv6,1);
 993         SSVAL(cli->outbuf,smb_vwv7,0);
 994
 995         p = smb_buf(cli->outbuf);
 996         SIVAL(p, 0, cli->pid);
 997         SOFF_T_R(p, 4, offset);
 998         SOFF_T_R(p, 12, len);
 999         p += 20;
1000         cli_setup_bcc(cli, p);
1001         cli_send_smb(cli);
1002         if (!cli_receive_smb(cli)) {
1003                 return False;
1004         }
1005
1006         if (cli_is_error(cli)) {
1007                 return False;
1008         }
1009
1010         return True;
1011 }
1012
1013
1014 /****************************************************************************
1015  Do a SMBgetattrE call.
1016 ****************************************************************************/
1017
1018 BOOL cli_getattrE(struct cli_state *cli, int fd,
1019                   uint16 *attr, SMB_BIG_UINT *size,
1020                   time_t *c_time, time_t *a_time, time_t *m_time)
1021 {
1022         memset(cli->outbuf,'\0',smb_size);
1023         memset(cli->inbuf,'\0',smb_size);
1024
1025         set_message(cli->outbuf,1,0,True);
1026
1027         SCVAL(cli->outbuf,smb_com,SMBgetattrE);
1028         SSVAL(cli->outbuf,smb_tid,cli->cnum);
1029         cli_setup_packet(cli);
1030
1031         SSVAL(cli->outbuf,smb_vwv0,fd);
1032
1033         cli_send_smb(cli);
1034         if (!cli_receive_smb(cli)) {
1035                 return False;
1036         }
1037
1038         if (cli_is_error(cli)) {
1039                 return False;
1040         }
1041
1042         if (size) {
1043                 *size = IVAL(cli->inbuf, smb_vwv6);
1044         }
1045
1046         if (attr) {
1047                 *attr = SVAL(cli->inbuf,smb_vwv10);
1048         }
1049
1050         if (c_time) {
1051                 *c_time = make_unix_date3(cli->inbuf+smb_vwv0);
1052         }
1053
1054         if (a_time) {
1055                 *a_time = make_unix_date3(cli->inbuf+smb_vwv2);
1056         }
1057
1058         if (m_time) {
1059                 *m_time = make_unix_date3(cli->inbuf+smb_vwv4);
1060         }
1061
1062         return True;
1063 }
1064
1065 /****************************************************************************
1066  Do a SMBgetatr call
1067 ****************************************************************************/
1068
1069 BOOL cli_getatr(struct cli_state *cli, const char *fname,
1070                 uint16 *attr, size_t *size, time_t *t)
1071 {
1072         char *p;
1073
1074         memset(cli->outbuf,'\0',smb_size);
1075         memset(cli->inbuf,'\0',smb_size);
1076
1077         set_message(cli->outbuf,0,0,True);
1078
1079         SCVAL(cli->outbuf,smb_com,SMBgetatr);
1080         SSVAL(cli->outbuf,smb_tid,cli->cnum);
1081         cli_setup_packet(cli);
1082
1083         p = smb_buf(cli->outbuf);
1084         *p++ = 4;
1085         p += clistr_push(cli, p, fname, -1, STR_TERMINATE);
1086
1087         cli_setup_bcc(cli, p);
1088
1089         cli_send_smb(cli);
1090         if (!cli_receive_smb(cli)) {
1091                 return False;
1092         }
1093
1094         if (cli_is_error(cli)) {
1095                 return False;
1096         }
1097
1098         if (size) {
1099                 *size = IVAL(cli->inbuf, smb_vwv3);
1100         }
1101
1102         if (t) {
1103                 *t = make_unix_date3(cli->inbuf+smb_vwv1);
1104         }
1105
1106         if (attr) {
1107                 *attr = SVAL(cli->inbuf,smb_vwv0);
1108         }
1109
1110
1111         return True;
1112 }
1113
1114 /****************************************************************************
1115  Do a SMBsetattrE call.
1116 ****************************************************************************/
1117
1118 BOOL cli_setattrE(struct cli_state *cli, int fd,
1119                   time_t c_time, time_t a_time, time_t m_time)
1120
1121 {
1122         char *p;
1123
1124         memset(cli->outbuf,'\0',smb_size);
1125         memset(cli->inbuf,'\0',smb_size);
1126
1127         set_message(cli->outbuf,7,0,True);
1128
1129         SCVAL(cli->outbuf,smb_com,SMBsetattrE);
1130         SSVAL(cli->outbuf,smb_tid,cli->cnum);
1131         cli_setup_packet(cli);
1132
1133         SSVAL(cli->outbuf,smb_vwv0, fd);
1134         put_dos_date3(cli->outbuf,smb_vwv1, c_time);
1135         put_dos_date3(cli->outbuf,smb_vwv3, a_time);
1136         put_dos_date3(cli->outbuf,smb_vwv5, m_time);
1137
1138         p = smb_buf(cli->outbuf);
1139         *p++ = 4;
1140
1141         cli_setup_bcc(cli, p);
1142
1143         cli_send_smb(cli);
1144         if (!cli_receive_smb(cli)) {
1145                 return False;
1146         }
1147
1148         if (cli_is_error(cli)) {
1149                 return False;
1150         }
1151
1152         return True;
1153 }
1154
1155 /****************************************************************************
1156  Do a SMBsetatr call.
1157 ****************************************************************************/
1158
1159 BOOL cli_setatr(struct cli_state *cli, const char *fname, uint16 attr, time_t t)
1160 {
1161         char *p;
1162
1163         memset(cli->outbuf,'\0',smb_size);
1164         memset(cli->inbuf,'\0',smb_size);
1165
1166         set_message(cli->outbuf,8,0,True);
1167
1168         SCVAL(cli->outbuf,smb_com,SMBsetatr);
1169         SSVAL(cli->outbuf,smb_tid,cli->cnum);
1170         cli_setup_packet(cli);
1171
1172         SSVAL(cli->outbuf,smb_vwv0, attr);
1173         put_dos_date3(cli->outbuf,smb_vwv1, t);
1174
1175         p = smb_buf(cli->outbuf);
1176         *p++ = 4;
1177         p += clistr_push(cli, p, fname, -1, STR_TERMINATE);
1178         *p++ = 4;
1179
1180         cli_setup_bcc(cli, p);
1181
1182         cli_send_smb(cli);
1183         if (!cli_receive_smb(cli)) {
1184                 return False;
1185         }
1186
1187         if (cli_is_error(cli)) {
1188                 return False;
1189         }
1190
1191         return True;
1192 }
1193
1194 /****************************************************************************
1195  Check for existance of a dir.
1196 ****************************************************************************/
1197 BOOL cli_chkpath(struct cli_state *cli, const char *path)
1198 {
1199         pstring path2;
1200         char *p;
1201
1202         pstrcpy(path2,path);
1203         trim_char(path2,'\0','\\');
1204         if (!*path2)
1205                 *path2 = '\\';
1206
1207         memset(cli->outbuf,'\0',smb_size);
1208         set_message(cli->outbuf,0,0,True);
1209         SCVAL(cli->outbuf,smb_com,SMBchkpth);
1210         SSVAL(cli->outbuf,smb_tid,cli->cnum);
1211         cli_setup_packet(cli);
1212         p = smb_buf(cli->outbuf);
1213         *p++ = 4;
1214         p += clistr_push(cli, p, path2, -1, STR_TERMINATE);
1215
1216         cli_setup_bcc(cli, p);
1217
1218         cli_send_smb(cli);
1219         if (!cli_receive_smb(cli)) {
1220                 return False;
1221         }
1222
1223         if (cli_is_error(cli)) return False;
1224
1225         return True;
1226 }
1227
1228 /****************************************************************************
1229  Query disk space.
1230 ****************************************************************************/
1231
1232 BOOL cli_dskattr(struct cli_state *cli, int *bsize, int *total, int *avail)
1233 {
1234         memset(cli->outbuf,'\0',smb_size);
1235         set_message(cli->outbuf,0,0,True);
1236         SCVAL(cli->outbuf,smb_com,SMBdskattr);
1237         SSVAL(cli->outbuf,smb_tid,cli->cnum);
1238         cli_setup_packet(cli);
1239
1240         cli_send_smb(cli);
1241         if (!cli_receive_smb(cli)) {
1242                 return False;
1243         }
1244
1245         *bsize = SVAL(cli->inbuf,smb_vwv1)*SVAL(cli->inbuf,smb_vwv2);
1246         *total = SVAL(cli->inbuf,smb_vwv0);
1247         *avail = SVAL(cli->inbuf,smb_vwv3);
1248
1249         return True;
1250 }
1251
1252 /****************************************************************************
1253  Create and open a temporary file.
1254 ****************************************************************************/
1255
1256 int cli_ctemp(struct cli_state *cli, const char *path, char **tmp_path)
1257 {
1258         int len;
1259         char *p;
1260
1261         memset(cli->outbuf,'\0',smb_size);
1262         memset(cli->inbuf,'\0',smb_size);
1263
1264         set_message(cli->outbuf,3,0,True);
1265
1266         SCVAL(cli->outbuf,smb_com,SMBctemp);
1267         SSVAL(cli->outbuf,smb_tid,cli->cnum);
1268         cli_setup_packet(cli);
1269
1270         SSVAL(cli->outbuf,smb_vwv0,0);
1271         SIVALS(cli->outbuf,smb_vwv1,-1);
1272
1273         p = smb_buf(cli->outbuf);
1274         *p++ = 4;
1275         p += clistr_push(cli, p, path, -1, STR_TERMINATE);
1276
1277         cli_setup_bcc(cli, p);
1278
1279         cli_send_smb(cli);
1280         if (!cli_receive_smb(cli)) {
1281                 return -1;
1282         }
1283
1284         if (cli_is_error(cli)) {
1285                 return -1;
1286         }
1287
1288         /* despite the spec, the result has a -1, followed by
1289            length, followed by name */
1290         p = smb_buf(cli->inbuf);
1291         p += 4;
1292         len = smb_buflen(cli->inbuf) - 4;
1293         if (len <= 0) return -1;
1294
1295         if (tmp_path) {
1296                 pstring path2;
1297                 clistr_pull(cli, path2, p,
1298                             sizeof(path2), len, STR_ASCII);
1299                 *tmp_path = strdup(path2);
1300         }
1301
1302         return SVAL(cli->inbuf,smb_vwv0);
1303 }
1304
1305
1306 /*
1307    send a raw ioctl - used by the torture code
1308 */
1309 NTSTATUS cli_raw_ioctl(struct cli_state *cli, int fnum, uint32 code, DATA_BLOB *blob)
1310 {
1311         memset(cli->outbuf,'\0',smb_size);
1312         memset(cli->inbuf,'\0',smb_size);
1313
1314         set_message(cli->outbuf, 3, 0, True);
1315         SCVAL(cli->outbuf,smb_com,SMBioctl);
1316         cli_setup_packet(cli);
1317
1318         SSVAL(cli->outbuf, smb_vwv0, fnum);
1319         SSVAL(cli->outbuf, smb_vwv1, code>>16);
1320         SSVAL(cli->outbuf, smb_vwv2, (code&0xFFFF));
1321
1322         cli_send_smb(cli);
1323         if (!cli_receive_smb(cli)) {
1324                 return NT_STATUS_UNEXPECTED_NETWORK_ERROR;
1325         }
1326
1327         if (cli_is_error(cli)) {
1328                 return cli_nt_error(cli);
1329         }
1330
1331         *blob = data_blob(NULL, 0);
1332
1333         return NT_STATUS_OK;
1334 }
1335
1336 /*********************************************************
1337  Set an extended attribute utility fn.
1338 *********************************************************/
1339
1340 static BOOL cli_set_ea(struct cli_state *cli, uint16 setup, char *param, unsigned int param_len,
1341                         const char *ea_name, const char *ea_val, size_t ea_len)
1342 {
1343         unsigned int data_len = 0;
1344         char *data = NULL;
1345         char *rparam=NULL, *rdata=NULL;
1346         char *p;
1347         size_t ea_namelen = strlen(ea_name);
1348
1349         data_len = 4 + 4 + ea_namelen + 1 + ea_len;
1350         data = malloc(data_len);
1351         if (!data) {
1352                 return False;
1353         }
1354         p = data;
1355         SIVAL(p,0,data_len);
1356         p += 4;
1357         SCVAL(p, 0, 0); /* EA flags. */
1358         SCVAL(p, 1, ea_namelen);
1359         SSVAL(p, 2, ea_len);
1360         memcpy(p+4, ea_name, ea_namelen+1); /* Copy in the name. */
1361         memcpy(p+4+ea_namelen+1, ea_val, ea_len);
1362
1363         if (!cli_send_trans(cli, SMBtrans2,
1364                 NULL,                        /* name */
1365                 -1, 0,                          /* fid, flags */
1366                 &setup, 1, 0,                   /* setup, length, max */
1367                 param, param_len, 2,            /* param, length, max */
1368                 data,  data_len, cli->max_xmit /* data, length, max */
1369                 )) {
1370                         return False;
1371         }
1372
1373         if (!cli_receive_trans(cli, SMBtrans2,
1374                 &rparam, &param_len,
1375                 &rdata, &data_len)) {
1376                         return False;
1377         }
1378
1379         SAFE_FREE(data);
1380         SAFE_FREE(rdata);
1381         SAFE_FREE(rparam);
1382
1383         return True;
1384 }
1385
1386 /*********************************************************
1387  Set an extended attribute on a pathname.
1388 *********************************************************/
1389
1390 BOOL cli_set_ea_path(struct cli_state *cli, const char *path, const char *ea_name, const char *ea_val, size_t ea_len)
1391 {
1392         uint16 setup = TRANSACT2_SETPATHINFO;
1393         unsigned int param_len = 0;
1394         char param[sizeof(pstring)+6];
1395         size_t srclen = 2*(strlen(path)+1);
1396         char *p;
1397
1398         memset(param, 0, sizeof(param));
1399         SSVAL(param,0,SMB_INFO_SET_EA);
1400         p = &param[6];
1401
1402         p += clistr_push(cli, p, path, MIN(srclen, sizeof(param)-6), STR_TERMINATE);
1403         param_len = PTR_DIFF(p, param);
1404
1405         return cli_set_ea(cli, setup, param, param_len, ea_name, ea_val, ea_len);
1406 }
1407
1408 /*********************************************************
1409  Set an extended attribute on an fnum.
1410 *********************************************************/
1411
1412 BOOL cli_set_ea_fnum(struct cli_state *cli, int fnum, const char *ea_name, const char *ea_val, size_t ea_len)
1413 {
1414         char param[6];
1415         uint16 setup = TRANSACT2_SETFILEINFO;
1416
1417         memset(param, 0, 6);
1418         SSVAL(param,0,fnum);
1419         SSVAL(param,2,SMB_INFO_SET_EA);
1420
1421         return cli_set_ea(cli, setup, param, 6, ea_name, ea_val, ea_len);
1422 }
1423
1424 /*********************************************************
1425  Get an extended attribute list tility fn.
1426 *********************************************************/
1427
1428 static BOOL cli_get_ea_list(struct cli_state *cli,
1429                 uint16 setup, char *param, unsigned int param_len,
1430                 TALLOC_CTX *ctx,
1431                 size_t *pnum_eas,
1432                 struct ea_struct **pea_list)
1433 {
1434         unsigned int data_len = 0;
1435         unsigned int rparam_len, rdata_len;
1436         char *rparam=NULL, *rdata=NULL;
1437         char *p;
1438         size_t ea_size;
1439         size_t num_eas;
1440         BOOL ret = False;
1441         struct ea_struct *ea_list;
1442
1443         *pnum_eas = 0;
1444         *pea_list = NULL;
1445
1446         if (!cli_send_trans(cli, SMBtrans2,
1447                         NULL,           /* Name */
1448                         -1, 0,          /* fid, flags */
1449                         &setup, 1, 0,   /* setup, length, max */
1450                         param, param_len, 10, /* param, length, max */
1451                         NULL, data_len, cli->max_xmit /* data, length, max */
1452                                 )) {
1453                 return False;
1454         }
1455
1456         if (!cli_receive_trans(cli, SMBtrans2,
1457                         &rparam, &rparam_len,
1458                         &rdata, &rdata_len)) {
1459                 return False;
1460         }
1461
1462         if (!rdata || rdata_len < 4) {
1463                 goto out;
1464         }
1465
1466         ea_size = (size_t)IVAL(rdata,0);
1467         if (ea_size > rdata_len) {
1468                 goto out;
1469         }
1470
1471         if (ea_size == 0) {
1472                 /* No EA's present. */
1473                 ret = True;
1474                 goto out;
1475         }
1476
1477         p = rdata + 4;
1478         ea_size -= 4;
1479
1480         /* Validate the EA list and count it. */
1481         for (num_eas = 0; ea_size >= 4; num_eas++) {
1482                 unsigned int ea_namelen = CVAL(p,1);
1483                 unsigned int ea_valuelen = SVAL(p,2);
1484                 if (ea_namelen == 0) {
1485                         goto out;
1486                 }
1487                 if (4 + ea_namelen + 1 + ea_valuelen > ea_size) {
1488                         goto out;
1489                 }
1490                 ea_size -= 4 + ea_namelen + 1 + ea_valuelen;
1491                 p += 4 + ea_namelen + 1 + ea_valuelen;
1492         }
1493
1494         if (num_eas == 0) {
1495                 ret = True;
1496                 goto out;
1497         }
1498
1499         *pnum_eas = num_eas;
1500         if (!pea_list) {
1501                 /* Caller only wants number of EA's. */
1502                 ret = True;
1503                 goto out;
1504         }
1505
1506         ea_list = (struct ea_struct *)talloc(ctx, num_eas*sizeof(struct ea_struct));
1507         if (!ea_list) {
1508                 goto out;
1509         }
1510
1511         ea_size = (size_t)IVAL(rdata,0);
1512         p = rdata + 4;
1513
1514         for (num_eas = 0; num_eas < *pnum_eas; num_eas++ ) {
1515                 struct ea_struct *ea = &ea_list[num_eas];
1516                 fstring unix_ea_name;
1517                 unsigned int ea_namelen = CVAL(p,1);
1518                 unsigned int ea_valuelen = SVAL(p,2);
1519
1520                 ea->flags = CVAL(p,0);
1521                 unix_ea_name[0] = '\0';
1522                 pull_ascii_fstring(unix_ea_name, p + 4);
1523                 ea->name = talloc_strdup(ctx, unix_ea_name);
1524                 /* Ensure the value is null terminated (in case it's a string). */
1525                 ea->value = data_blob_talloc(ctx, NULL, ea_valuelen + 1);
1526                 if (!ea->value.data) {
1527                         goto out;
1528                 }
1529                 if (ea_valuelen) {
1530                         memcpy(ea->value.data, p+4+ea_namelen+1, ea_valuelen);
1531                 }
1532                 ea->value.data[ea_valuelen] = 0;
1533                 ea->value.length--;
1534                 p += 4 + ea_namelen + 1 + ea_valuelen;
1535         }
1536
1537         *pea_list = ea_list;
1538         ret = True;
1539
1540  out :
1541
1542         SAFE_FREE(rdata);
1543         SAFE_FREE(rparam);
1544         return ret;
1545 }
1546
1547 /*********************************************************
1548  Get an extended attribute list from a pathname.
1549 *********************************************************/
1550
1551 BOOL cli_get_ea_list_path(struct cli_state *cli, const char *path,
1552                 TALLOC_CTX *ctx,
1553                 size_t *pnum_eas,
1554                 struct ea_struct **pea_list)
1555 {
1556         uint16 setup = TRANSACT2_QPATHINFO;
1557         unsigned int param_len = 0;
1558         char param[sizeof(pstring)+6];
1559         char *p;
1560
1561         p = param;
1562         memset(p, 0, 6);
1563         SSVAL(p, 0, SMB_INFO_QUERY_ALL_EAS);
1564         p += 6;
1565         p += clistr_push(cli, p, path, sizeof(pstring)-6, STR_TERMINATE);
1566         param_len = PTR_DIFF(p, param);
1567
1568         return cli_get_ea_list(cli, setup, param, param_len, ctx, pnum_eas, pea_list);
1569 }
1570
1571 /*********************************************************
1572  Get an extended attribute list from an fnum.
1573 *********************************************************/
1574
1575 BOOL cli_get_ea_list_fnum(struct cli_state *cli, int fnum,
1576                 TALLOC_CTX *ctx,
1577                 size_t *pnum_eas,
1578                 struct ea_struct **pea_list)
1579 {
1580         uint16 setup = TRANSACT2_QFILEINFO;
1581         char param[6];
1582
1583         memset(param, 0, 6);
1584         SSVAL(param,0,fnum);
1585         SSVAL(param,2,SMB_INFO_SET_EA);
1586
1587         return cli_get_ea_list(cli, setup, param, 6, ctx, pnum_eas, pea_list);
1588 }