source/smbd/trans2.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    SMB transaction2 handling
   4    Copyright (C) Jeremy Allison                 1994-2003
   5    Copyright (C) Stefan (metze) Metzmacher      2003
   6    Copyright (C) Volker Lendecke                2005
   7    Copyright (C) Steve French                   2005
   8
   9    Extensively modified by Andrew Tridgell, 1995
  10
  11    This program is free software; you can redistribute it and/or modify
  12    it under the terms of the GNU General Public License as published by
  13    the Free Software Foundation; either version 2 of the License, or
  14    (at your option) any later version.
  15
  16    This program is distributed in the hope that it will be useful,
  17    but WITHOUT ANY WARRANTY; without even the implied warranty of
  18    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19    GNU General Public License for more details.
  20
  21    You should have received a copy of the GNU General Public License
  22    along with this program; if not, write to the Free Software
  23    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  24 */
  25
  26 #include "includes.h"
  27
  28 extern int max_send;
  29 extern enum protocol_types Protocol;
  30 extern int smb_read_error;
  31 extern uint32 global_client_caps;
  32 extern struct current_user current_user;
  33
  34 #define get_file_size(sbuf) ((sbuf).st_size)
  35 #define DIR_ENTRY_SAFETY_MARGIN 4096
  36
  37 /********************************************************************
  38  Roundup a value to the nearest allocation roundup size boundary.
  39  Only do this for Windows clients.
  40 ********************************************************************/
  41
  42 SMB_BIG_UINT smb_roundup(connection_struct *conn, SMB_BIG_UINT val)
  43 {
  44         SMB_BIG_UINT rval = lp_allocation_roundup_size(SNUM(conn));
  45
  46         /* Only roundup for Windows clients. */
  47         enum remote_arch_types ra_type = get_remote_arch();
  48         if (rval && (ra_type != RA_SAMBA) && (ra_type != RA_CIFSFS)) {
  49                 val = SMB_ROUNDUP(val,rval);
  50         }
  51         return val;
  52 }
  53
  54 /********************************************************************
  55  Given a stat buffer return the allocated size on disk, taking into
  56  account sparse files.
  57 ********************************************************************/
  58
  59 SMB_BIG_UINT get_allocation_size(connection_struct *conn, files_struct *fsp, SMB_STRUCT_STAT *sbuf)
  60 {
  61         SMB_BIG_UINT ret;
  62
  63         if(S_ISDIR(sbuf->st_mode)) {
  64                 return 0;
  65         }
  66
  67 #if defined(HAVE_STAT_ST_BLOCKS) && defined(STAT_ST_BLOCKSIZE)
  68         ret = (SMB_BIG_UINT)STAT_ST_BLOCKSIZE * (SMB_BIG_UINT)sbuf->st_blocks;
  69 #else
  70         ret = (SMB_BIG_UINT)get_file_size(*sbuf);
  71 #endif
  72
  73         if (fsp && fsp->initial_allocation_size)
  74                 ret = MAX(ret,fsp->initial_allocation_size);
  75
  76         return smb_roundup(conn, ret);
  77 }
  78
  79 /****************************************************************************
  80  Utility functions for dealing with extended attributes.
  81 ****************************************************************************/
  82
  83 static const char *prohibited_ea_names[] = {
  84         SAMBA_POSIX_INHERITANCE_EA_NAME,
  85         SAMBA_XATTR_DOS_ATTRIB,
  86         NULL
  87 };
  88
  89 /****************************************************************************
  90  Refuse to allow clients to overwrite our private xattrs.
  91 ****************************************************************************/
  92
  93 static BOOL samba_private_attr_name(const char *unix_ea_name)
  94 {
  95         int i;
  96
  97         for (i = 0; prohibited_ea_names[i]; i++) {
  98                 if (strequal( prohibited_ea_names[i], unix_ea_name))
  99                         return True;
 100         }
 101         return False;
 102 }
 103
 104 /****************************************************************************
 105  Get one EA value. Fill in a struct ea_struct.
 106 ****************************************************************************/
 107
 108 static BOOL get_ea_value(TALLOC_CTX *mem_ctx, connection_struct *conn, files_struct *fsp,
 109                                 const char *fname, char *ea_name, struct ea_struct *pea)
 110 {
 111         /* Get the value of this xattr. Max size is 64k. */
 112         size_t attr_size = 256;
 113         char *val = NULL;
 114         ssize_t sizeret;
 115
 116  again:
 117
 118         val = TALLOC_REALLOC_ARRAY(mem_ctx, val, char, attr_size);
 119         if (!val) {
 120                 return False;
 121         }
 122
 123         if (fsp && fsp->fh->fd != -1) {
 124                 sizeret = SMB_VFS_FGETXATTR(fsp, fsp->fh->fd, ea_name, val, attr_size);
 125         } else {
 126                 sizeret = SMB_VFS_GETXATTR(conn, fname, ea_name, val, attr_size);
 127         }
 128
 129         if (sizeret == -1 && errno == ERANGE && attr_size != 65536) {
 130                 attr_size = 65536;
 131                 goto again;
 132         }
 133
 134         if (sizeret == -1) {
 135                 return False;
 136         }
 137
 138         DEBUG(10,("get_ea_value: EA %s is of length %u: ", ea_name, (unsigned int)sizeret));
 139         dump_data(10, val, sizeret);
 140
 141         pea->flags = 0;
 142         if (strnequal(ea_name, "user.", 5)) {
 143                 pea->name = &ea_name[5];
 144         } else {
 145                 pea->name = ea_name;
 146         }
 147         pea->value.data = (unsigned char *)val;
 148         pea->value.length = (size_t)sizeret;
 149         return True;
 150 }
 151
 152 /****************************************************************************
 153  Return a linked list of the total EA's. Plus the total size
 154 ****************************************************************************/
 155
 156 static struct ea_list *get_ea_list_from_file(TALLOC_CTX *mem_ctx, connection_struct *conn, files_struct *fsp,
 157                                         const char *fname, size_t *pea_total_len)
 158 {
 159         /* Get a list of all xattrs. Max namesize is 64k. */
 160         size_t ea_namelist_size = 1024;
 161         char *ea_namelist;
 162         char *p;
 163         ssize_t sizeret;
 164         int i;
 165         struct ea_list *ea_list_head = NULL;
 166
 167         *pea_total_len = 0;
 168
 169         if (!lp_ea_support(SNUM(conn))) {
 170                 return NULL;
 171         }
 172
 173         for (i = 0, ea_namelist = TALLOC_ARRAY(mem_ctx, char, ea_namelist_size); i < 6;
 174              ea_namelist = TALLOC_REALLOC_ARRAY(mem_ctx, ea_namelist, char, ea_namelist_size), i++) {
 175
 176                 if (!ea_namelist) {
 177                         return NULL;
 178                 }
 179
 180                 if (fsp && fsp->fh->fd != -1) {
 181                         sizeret = SMB_VFS_FLISTXATTR(fsp, fsp->fh->fd, ea_namelist, ea_namelist_size);
 182                 } else {
 183                         sizeret = SMB_VFS_LISTXATTR(conn, fname, ea_namelist, ea_namelist_size);
 184                 }
 185
 186                 if (sizeret == -1 && errno == ERANGE) {
 187                         ea_namelist_size *= 2;
 188                 } else {
 189                         break;
 190                 }
 191         }
 192
 193         if (sizeret == -1)
 194                 return NULL;
 195
 196         DEBUG(10,("get_ea_list_from_file: ea_namelist size = %u\n", (unsigned int)sizeret ));
 197
 198         if (sizeret) {
 199                 for (p = ea_namelist; p - ea_namelist < sizeret; p += strlen(p) + 1) {
 200                         struct ea_list *listp;
 201
 202                         if (strnequal(p, "system.", 7) || samba_private_attr_name(p))
 203                                 continue;
 204
 205                         listp = TALLOC_P(mem_ctx, struct ea_list);
 206                         if (!listp)
 207                                 return NULL;
 208
 209                         if (!get_ea_value(mem_ctx, conn, fsp, fname, p, &listp->ea)) {
 210                                 return NULL;
 211                         }
 212
 213                         {
 214                                 fstring dos_ea_name;
 215                                 push_ascii_fstring(dos_ea_name, listp->ea.name);
 216                                 *pea_total_len += 4 + strlen(dos_ea_name) + 1 + listp->ea.value.length;
 217                                 DEBUG(10,("get_ea_list_from_file: total_len = %u, %s, val len = %u\n",
 218                                         (unsigned int)*pea_total_len, dos_ea_name,
 219                                         (unsigned int)listp->ea.value.length ));
 220                         }
 221                         DLIST_ADD_END(ea_list_head, listp, struct ea_list *);
 222                 }
 223                 /* Add on 4 for total length. */
 224                 if (*pea_total_len) {
 225                         *pea_total_len += 4;
 226                 }
 227         }
 228
 229         DEBUG(10,("get_ea_list_from_file: total_len = %u\n", (unsigned int)*pea_total_len));
 230         return ea_list_head;
 231 }
 232
 233 /****************************************************************************
 234  Fill a qfilepathinfo buffer with EA's. Returns the length of the buffer
 235  that was filled.
 236 ****************************************************************************/
 237
 238 static unsigned int fill_ea_buffer(TALLOC_CTX *mem_ctx, char *pdata, unsigned int total_data_size,
 239         connection_struct *conn, struct ea_list *ea_list)
 240 {
 241         unsigned int ret_data_size = 4;
 242         char *p = pdata;
 243
 244         SMB_ASSERT(total_data_size >= 4);
 245
 246         if (!lp_ea_support(SNUM(conn))) {
 247                 SIVAL(pdata,4,0);
 248                 return 4;
 249         }
 250
 251         for (p = pdata + 4; ea_list; ea_list = ea_list->next) {
 252                 size_t dos_namelen;
 253                 fstring dos_ea_name;
 254                 push_ascii_fstring(dos_ea_name, ea_list->ea.name);
 255                 dos_namelen = strlen(dos_ea_name);
 256                 if (dos_namelen > 255 || dos_namelen == 0) {
 257                         break;
 258                 }
 259                 if (ea_list->ea.value.length > 65535) {
 260                         break;
 261                 }
 262                 if (4 + dos_namelen + 1 + ea_list->ea.value.length > total_data_size) {
 263                         break;
 264                 }
 265
 266                 /* We know we have room. */
 267                 SCVAL(p,0,ea_list->ea.flags);
 268                 SCVAL(p,1,dos_namelen);
 269                 SSVAL(p,2,ea_list->ea.value.length);
 270                 fstrcpy(p+4, dos_ea_name);
 271                 memcpy( p + 4 + dos_namelen + 1, ea_list->ea.value.data, ea_list->ea.value.length);
 272
 273                 total_data_size -= 4 + dos_namelen + 1 + ea_list->ea.value.length;
 274                 p += 4 + dos_namelen + 1 + ea_list->ea.value.length;
 275         }
 276
 277         ret_data_size = PTR_DIFF(p, pdata);
 278         DEBUG(10,("fill_ea_buffer: data_size = %u\n", ret_data_size ));
 279         SIVAL(pdata,0,ret_data_size);
 280         return ret_data_size;
 281 }
 282
 283 static unsigned int estimate_ea_size(connection_struct *conn, files_struct *fsp, const char *fname)
 284 {
 285         size_t total_ea_len = 0;
 286         TALLOC_CTX *mem_ctx = NULL;
 287
 288         if (!lp_ea_support(SNUM(conn))) {
 289                 return 0;
 290         }
 291         mem_ctx = talloc_init("estimate_ea_size");
 292         (void)get_ea_list_from_file(mem_ctx, conn, fsp, fname, &total_ea_len);
 293         talloc_destroy(mem_ctx);
 294         return total_ea_len;
 295 }
 296
 297 /****************************************************************************
 298  Ensure the EA name is case insensitive by matching any existing EA name.
 299 ****************************************************************************/
 300
 301 static void canonicalize_ea_name(connection_struct *conn, files_struct *fsp, const char *fname, fstring unix_ea_name)
 302 {
 303         size_t total_ea_len;
 304         TALLOC_CTX *mem_ctx = talloc_init("canonicalize_ea_name");
 305         struct ea_list *ea_list = get_ea_list_from_file(mem_ctx, conn, fsp, fname, &total_ea_len);
 306
 307         for (; ea_list; ea_list = ea_list->next) {
 308                 if (strequal(&unix_ea_name[5], ea_list->ea.name)) {
 309                         DEBUG(10,("canonicalize_ea_name: %s -> %s\n",
 310                                 &unix_ea_name[5], ea_list->ea.name));
 311                         safe_strcpy(&unix_ea_name[5], ea_list->ea.name, sizeof(fstring)-6);
 312                         break;
 313                 }
 314         }
 315         talloc_destroy(mem_ctx);
 316 }
 317
 318 /****************************************************************************
 319  Set or delete an extended attribute.
 320 ****************************************************************************/
 321
 322 NTSTATUS set_ea(connection_struct *conn, files_struct *fsp, const char *fname, struct ea_list *ea_list)
 323 {
 324         if (!lp_ea_support(SNUM(conn))) {
 325                 return NT_STATUS_EAS_NOT_SUPPORTED;
 326         }
 327
 328         for (;ea_list; ea_list = ea_list->next) {
 329                 int ret;
 330                 fstring unix_ea_name;
 331
 332                 fstrcpy(unix_ea_name, "user."); /* All EA's must start with user. */
 333                 fstrcat(unix_ea_name, ea_list->ea.name);
 334
 335                 canonicalize_ea_name(conn, fsp, fname, unix_ea_name);
 336
 337                 DEBUG(10,("set_ea: ea_name %s ealen = %u\n", unix_ea_name, (unsigned int)ea_list->ea.value.length));
 338
 339                 if (samba_private_attr_name(unix_ea_name)) {
 340                         DEBUG(10,("set_ea: ea name %s is a private Samba name.\n", unix_ea_name));
 341                         return NT_STATUS_ACCESS_DENIED;
 342                 }
 343
 344                 if (ea_list->ea.value.length == 0) {
 345                         /* Remove the attribute. */
 346                         if (fsp && (fsp->fh->fd != -1)) {
 347                                 DEBUG(10,("set_ea: deleting ea name %s on file %s by file descriptor.\n",
 348                                         unix_ea_name, fsp->fsp_name));
 349                                 ret = SMB_VFS_FREMOVEXATTR(fsp, fsp->fh->fd, unix_ea_name);
 350                         } else {
 351                                 DEBUG(10,("set_ea: deleting ea name %s on file %s.\n",
 352                                         unix_ea_name, fname));
 353                                 ret = SMB_VFS_REMOVEXATTR(conn, fname, unix_ea_name);
 354                         }
 355 #ifdef ENOATTR
 356                         /* Removing a non existent attribute always succeeds. */
 357                         if (ret == -1 && errno == ENOATTR) {
 358                                 DEBUG(10,("set_ea: deleting ea name %s didn't exist - succeeding by default.\n",
 359                                                 unix_ea_name));
 360                                 ret = 0;
 361                         }
 362 #endif
 363                 } else {
 364                         if (fsp && (fsp->fh->fd != -1)) {
 365                                 DEBUG(10,("set_ea: setting ea name %s on file %s by file descriptor.\n",
 366                                         unix_ea_name, fsp->fsp_name));
 367                                 ret = SMB_VFS_FSETXATTR(fsp, fsp->fh->fd, unix_ea_name,
 368                                                         ea_list->ea.value.data, ea_list->ea.value.length, 0);
 369                         } else {
 370                                 DEBUG(10,("set_ea: setting ea name %s on file %s.\n",
 371                                         unix_ea_name, fname));
 372                                 ret = SMB_VFS_SETXATTR(conn, fname, unix_ea_name,
 373                                                         ea_list->ea.value.data, ea_list->ea.value.length, 0);
 374                         }
 375                 }
 376
 377                 if (ret == -1) {
 378 #ifdef ENOTSUP
 379                         if (errno == ENOTSUP) {
 380                                 return NT_STATUS_EAS_NOT_SUPPORTED;
 381                         }
 382 #endif
 383                         return map_nt_error_from_unix(errno);
 384                 }
 385
 386         }
 387         return NT_STATUS_OK;
 388 }
 389 /****************************************************************************
 390  Read a list of EA names from an incoming data buffer. Create an ea_list with them.
 391 ****************************************************************************/
 392
 393 static struct ea_list *read_ea_name_list(TALLOC_CTX *ctx, const char *pdata, size_t data_size)
 394 {
 395         struct ea_list *ea_list_head = NULL;
 396         size_t offset = 0;
 397
 398         while (offset + 2 < data_size) {
 399                 struct ea_list *eal = TALLOC_ZERO_P(ctx, struct ea_list);
 400                 unsigned int namelen = CVAL(pdata,offset);
 401
 402                 offset++; /* Go past the namelen byte. */
 403
 404                 /* integer wrap paranioa. */
 405                 if ((offset + namelen < offset) || (offset + namelen < namelen) ||
 406                                 (offset > data_size) || (namelen > data_size) ||
 407                                 (offset + namelen >= data_size)) {
 408                         break;
 409                 }
 410                 /* Ensure the name is null terminated. */
 411                 if (pdata[offset + namelen] != '\0') {
 412                         return NULL;
 413                 }
 414                 pull_ascii_talloc(ctx, &eal->ea.name, &pdata[offset]);
 415                 if (!eal->ea.name) {
 416                         return NULL;
 417                 }
 418
 419                 offset += (namelen + 1); /* Go past the name + terminating zero. */
 420                 DLIST_ADD_END(ea_list_head, eal, struct ea_list *);
 421                 DEBUG(10,("read_ea_name_list: read ea name %s\n", eal->ea.name));
 422         }
 423
 424         return ea_list_head;
 425 }
 426
 427 /****************************************************************************
 428  Read one EA list entry from the buffer.
 429 ****************************************************************************/
 430
 431 struct ea_list *read_ea_list_entry(TALLOC_CTX *ctx, const char *pdata, size_t data_size, size_t *pbytes_used)
 432 {
 433         struct ea_list *eal = TALLOC_ZERO_P(ctx, struct ea_list);
 434         uint16 val_len;
 435         unsigned int namelen;
 436
 437         if (!eal) {
 438                 return NULL;
 439         }
 440
 441         if (data_size < 6) {
 442                 return NULL;
 443         }
 444
 445         eal->ea.flags = CVAL(pdata,0);
 446         namelen = CVAL(pdata,1);
 447         val_len = SVAL(pdata,2);
 448
 449         if (4 + namelen + 1 + val_len > data_size) {
 450                 return NULL;
 451         }
 452
 453         /* Ensure the name is null terminated. */
 454         if (pdata[namelen + 4] != '\0') {
 455                 return NULL;
 456         }
 457         pull_ascii_talloc(ctx, &eal->ea.name, pdata + 4);
 458         if (!eal->ea.name) {
 459                 return NULL;
 460         }
 461
 462         eal->ea.value = data_blob_talloc(eal, NULL, (size_t)val_len + 1);
 463         if (!eal->ea.value.data) {
 464                 return NULL;
 465         }
 466
 467         memcpy(eal->ea.value.data, pdata + 4 + namelen + 1, val_len);
 468
 469         /* Ensure we're null terminated just in case we print the value. */
 470         eal->ea.value.data[val_len] = '\0';
 471         /* But don't count the null. */
 472         eal->ea.value.length--;
 473
 474         if (pbytes_used) {
 475                 *pbytes_used = 4 + namelen + 1 + val_len;
 476         }
 477
 478         DEBUG(10,("read_ea_list_entry: read ea name %s\n", eal->ea.name));
 479         dump_data(10, (const char *)eal->ea.value.data, eal->ea.value.length);
 480
 481         return eal;
 482 }
 483
 484 /****************************************************************************
 485  Read a list of EA names and data from an incoming data buffer. Create an ea_list with them.
 486 ****************************************************************************/
 487
 488 static struct ea_list *read_ea_list(TALLOC_CTX *ctx, const char *pdata, size_t data_size)
 489 {
 490         struct ea_list *ea_list_head = NULL;
 491         size_t offset = 0;
 492         size_t bytes_used = 0;
 493
 494         while (offset < data_size) {
 495                 struct ea_list *eal = read_ea_list_entry(ctx, pdata + offset, data_size - offset, &bytes_used);
 496
 497                 if (!eal) {
 498                         return NULL;
 499                 }
 500
 501                 DLIST_ADD_END(ea_list_head, eal, struct ea_list *);
 502                 offset += bytes_used;
 503         }
 504
 505         return ea_list_head;
 506 }
 507
 508 /****************************************************************************
 509  Count the total EA size needed.
 510 ****************************************************************************/
 511
 512 static size_t ea_list_size(struct ea_list *ealist)
 513 {
 514         fstring dos_ea_name;
 515         struct ea_list *listp;
 516         size_t ret = 0;
 517
 518         for (listp = ealist; listp; listp = listp->next) {
 519                 push_ascii_fstring(dos_ea_name, listp->ea.name);
 520                 ret += 4 + strlen(dos_ea_name) + 1 + listp->ea.value.length;
 521         }
 522         /* Add on 4 for total length. */
 523         if (ret) {
 524                 ret += 4;
 525         }
 526
 527         return ret;
 528 }
 529
 530 /****************************************************************************
 531  Return a union of EA's from a file list and a list of names.
 532  The TALLOC context for the two lists *MUST* be identical as we steal
 533  memory from one list to add to another. JRA.
 534 ****************************************************************************/
 535
 536 static struct ea_list *ea_list_union(struct ea_list *name_list, struct ea_list *file_list, size_t *total_ea_len)
 537 {
 538         struct ea_list *nlistp, *flistp;
 539
 540         for (nlistp = name_list; nlistp; nlistp = nlistp->next) {
 541                 for (flistp = file_list; flistp; flistp = flistp->next) {
 542                         if (strequal(nlistp->ea.name, flistp->ea.name)) {
 543                                 break;
 544                         }
 545                 }
 546
 547                 if (flistp) {
 548                         /* Copy the data from this entry. */
 549                         nlistp->ea.flags = flistp->ea.flags;
 550                         nlistp->ea.value = flistp->ea.value;
 551                 } else {
 552                         /* Null entry. */
 553                         nlistp->ea.flags = 0;
 554                         ZERO_STRUCT(nlistp->ea.value);
 555                 }
 556         }
 557
 558         *total_ea_len = ea_list_size(name_list);
 559         return name_list;
 560 }
 561
 562 /****************************************************************************
 563   Send the required number of replies back.
 564   We assume all fields other than the data fields are
 565   set correctly for the type of call.
 566   HACK ! Always assumes smb_setup field is zero.
 567 ****************************************************************************/
 568
 569 int send_trans2_replies(char *outbuf,
 570                         int bufsize,
 571                         const char *params,
 572                         int paramsize,
 573                         const char *pdata,
 574                         int datasize,
 575                         int max_data_bytes)
 576 {
 577         /* As we are using a protocol > LANMAN1 then the max_send
 578          variable must have been set in the sessetupX call.
 579          This takes precedence over the max_xmit field in the
 580          global struct. These different max_xmit variables should
 581          be merged as this is now too confusing */
 582
 583         int data_to_send = datasize;
 584         int params_to_send = paramsize;
 585         int useable_space;
 586         const char *pp = params;
 587         const char *pd = pdata;
 588         int params_sent_thistime, data_sent_thistime, total_sent_thistime;
 589         int alignment_offset = 1; /* JRA. This used to be 3. Set to 1 to make netmon parse ok. */
 590         int data_alignment_offset = 0;
 591
 592         /* Initially set the wcnt area to be 10 - this is true for all trans2 replies */
 593
 594         set_message(outbuf,10,0,True);
 595
 596         /* Modify the data_to_send and datasize and set the error if
 597            we're trying to send more than max_data_bytes. We still send
 598            the part of the packet(s) that fit. Strange, but needed
 599            for OS/2. */
 600
 601         if (max_data_bytes > 0 && datasize > max_data_bytes) {
 602                 DEBUG(5,("send_trans2_replies: max_data_bytes %d exceeded by data %d\n",
 603                         max_data_bytes, datasize ));
 604                 datasize = data_to_send = max_data_bytes;
 605                 error_packet_set(outbuf,ERRDOS,ERRbufferoverflow,STATUS_BUFFER_OVERFLOW,__LINE__,__FILE__);
 606         }
 607
 608         /* If there genuinely are no parameters or data to send just send the empty packet */
 609
 610         if(params_to_send == 0 && data_to_send == 0) {
 611                 show_msg(outbuf);
 612                 if (!send_smb(smbd_server_fd(),outbuf))
 613                         exit_server_cleanly("send_trans2_replies: send_smb failed.");
 614                 return 0;
 615         }
 616
 617         /* When sending params and data ensure that both are nicely aligned */
 618         /* Only do this alignment when there is also data to send - else
 619                 can cause NT redirector problems. */
 620
 621         if (((params_to_send % 4) != 0) && (data_to_send != 0))
 622                 data_alignment_offset = 4 - (params_to_send % 4);
 623
 624         /* Space is bufsize minus Netbios over TCP header minus SMB header */
 625         /* The alignment_offset is to align the param bytes on an even byte
 626                 boundary. NT 4.0 Beta needs this to work correctly. */
 627
 628         useable_space = bufsize - ((smb_buf(outbuf)+ alignment_offset+data_alignment_offset) - outbuf);
 629
 630         /* useable_space can never be more than max_send minus the alignment offset. */
 631
 632         useable_space = MIN(useable_space, max_send - (alignment_offset+data_alignment_offset));
 633
 634         while (params_to_send || data_to_send) {
 635                 /* Calculate whether we will totally or partially fill this packet */
 636
 637                 total_sent_thistime = params_to_send + data_to_send + alignment_offset + data_alignment_offset;
 638
 639                 /* We can never send more than useable_space */
 640                 /*
 641                  * Note that 'useable_space' does not include the alignment offsets,
 642                  * but we must include the alignment offsets in the calculation of
 643                  * the length of the data we send over the wire, as the alignment offsets
 644                  * are sent here. Fix from Marc_Jacobsen@hp.com.
 645                  */
 646
 647                 total_sent_thistime = MIN(total_sent_thistime, useable_space+ alignment_offset + data_alignment_offset);
 648
 649                 set_message(outbuf, 10, total_sent_thistime, True);
 650
 651                 /* Set total params and data to be sent */
 652                 SSVAL(outbuf,smb_tprcnt,paramsize);
 653                 SSVAL(outbuf,smb_tdrcnt,datasize);
 654
 655                 /* Calculate how many parameters and data we can fit into
 656                  * this packet. Parameters get precedence
 657                  */
 658
 659                 params_sent_thistime = MIN(params_to_send,useable_space);
 660                 data_sent_thistime = useable_space - params_sent_thistime;
 661                 data_sent_thistime = MIN(data_sent_thistime,data_to_send);
 662
 663                 SSVAL(outbuf,smb_prcnt, params_sent_thistime);
 664
 665                 /* smb_proff is the offset from the start of the SMB header to the
 666                         parameter bytes, however the first 4 bytes of outbuf are
 667                         the Netbios over TCP header. Thus use smb_base() to subtract
 668                         them from the calculation */
 669
 670                 SSVAL(outbuf,smb_proff,((smb_buf(outbuf)+alignment_offset) - smb_base(outbuf)));
 671
 672                 if(params_sent_thistime == 0)
 673                         SSVAL(outbuf,smb_prdisp,0);
 674                 else
 675                         /* Absolute displacement of param bytes sent in this packet */
 676                         SSVAL(outbuf,smb_prdisp,pp - params);
 677
 678                 SSVAL(outbuf,smb_drcnt, data_sent_thistime);
 679                 if(data_sent_thistime == 0) {
 680                         SSVAL(outbuf,smb_droff,0);
 681                         SSVAL(outbuf,smb_drdisp, 0);
 682                 } else {
 683                         /* The offset of the data bytes is the offset of the
 684                                 parameter bytes plus the number of parameters being sent this time */
 685                         SSVAL(outbuf,smb_droff,((smb_buf(outbuf)+alignment_offset) -
 686                                 smb_base(outbuf)) + params_sent_thistime + data_alignment_offset);
 687                         SSVAL(outbuf,smb_drdisp, pd - pdata);
 688                 }
 689
 690                 /* Copy the param bytes into the packet */
 691
 692                 if(params_sent_thistime)
 693                         memcpy((smb_buf(outbuf)+alignment_offset),pp,params_sent_thistime);
 694
 695                 /* Copy in the data bytes */
 696                 if(data_sent_thistime)
 697                         memcpy(smb_buf(outbuf)+alignment_offset+params_sent_thistime+
 698                                 data_alignment_offset,pd,data_sent_thistime);
 699
 700                 DEBUG(9,("t2_rep: params_sent_thistime = %d, data_sent_thistime = %d, useable_space = %d\n",
 701                         params_sent_thistime, data_sent_thistime, useable_space));
 702                 DEBUG(9,("t2_rep: params_to_send = %d, data_to_send = %d, paramsize = %d, datasize = %d\n",
 703                         params_to_send, data_to_send, paramsize, datasize));
 704
 705                 /* Send the packet */
 706                 show_msg(outbuf);
 707                 if (!send_smb(smbd_server_fd(),outbuf))
 708                         exit_server_cleanly("send_trans2_replies: send_smb failed.");
 709
 710                 pp += params_sent_thistime;
 711                 pd += data_sent_thistime;
 712
 713                 params_to_send -= params_sent_thistime;
 714                 data_to_send -= data_sent_thistime;
 715
 716                 /* Sanity check */
 717                 if(params_to_send < 0 || data_to_send < 0) {
 718                         DEBUG(0,("send_trans2_replies failed sanity check pts = %d, dts = %d\n!!!",
 719                                 params_to_send, data_to_send));
 720                         return -1;
 721                 }
 722         }
 723
 724         return 0;
 725 }
 726
 727 /****************************************************************************
 728  Reply to a TRANSACT2_OPEN.
 729 ****************************************************************************/
 730
 731 static int call_trans2open(connection_struct *conn, char *inbuf, char *outbuf, int bufsize,
 732                                 char **pparams, int total_params, char **ppdata, int total_data,
 733                                 unsigned int max_data_bytes)
 734 {
 735         char *params = *pparams;
 736         char *pdata = *ppdata;
 737         int deny_mode;
 738         int32 open_attr;
 739         BOOL oplock_request;
 740 #if 0
 741         BOOL return_additional_info;
 742         int16 open_sattr;
 743         time_t open_time;
 744 #endif
 745         int open_ofun;
 746         uint32 open_size;
 747         char *pname;
 748         pstring fname;
 749         SMB_OFF_T size=0;
 750         int fattr=0,mtime=0;
 751         SMB_INO_T inode = 0;
 752         SMB_STRUCT_STAT sbuf;
 753         int smb_action = 0;
 754         files_struct *fsp;
 755         struct ea_list *ea_list = NULL;
 756         uint16 flags = 0;
 757         NTSTATUS status;
 758         uint32 access_mask;
 759         uint32 share_mode;
 760         uint32 create_disposition;
 761         uint32 create_options = 0;
 762
 763         /*
 764          * Ensure we have enough parameters to perform the operation.
 765          */
 766
 767         if (total_params < 29) {
 768                 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
 769         }
 770
 771         flags = SVAL(params, 0);
 772         deny_mode = SVAL(params, 2);
 773         open_attr = SVAL(params,6);
 774         oplock_request = (flags & REQUEST_OPLOCK) ? EXCLUSIVE_OPLOCK : 0;
 775         if (oplock_request) {
 776                 oplock_request |= (flags & REQUEST_BATCH_OPLOCK) ? BATCH_OPLOCK : 0;
 777         }
 778
 779 #if 0
 780         return_additional_info = BITSETW(params,0);
 781         open_sattr = SVAL(params, 4);
 782         open_time = make_unix_date3(params+8);
 783 #endif
 784         open_ofun = SVAL(params,12);
 785         open_size = IVAL(params,14);
 786         pname = &params[28];
 787
 788         if (IS_IPC(conn)) {
 789                 return(ERROR_DOS(ERRSRV,ERRaccess));
 790         }
 791
 792         srvstr_get_path(inbuf, fname, pname, sizeof(fname), total_params - 28, STR_TERMINATE, &status);
 793         if (!NT_STATUS_IS_OK(status)) {
 794                 return ERROR_NT(status);
 795         }
 796
 797         DEBUG(3,("call_trans2open %s deny_mode=0x%x attr=%d ofun=0x%x size=%d\n",
 798                 fname, (unsigned int)deny_mode, (unsigned int)open_attr,
 799                 (unsigned int)open_ofun, open_size));
 800
 801         /* XXXX we need to handle passed times, sattr and flags */
 802
 803         status = unix_convert(conn, fname, False, NULL, &sbuf);
 804         if (!NT_STATUS_IS_OK(status)) {
 805                 return ERROR_NT(status);
 806         }
 807
 808         status = check_name(conn, fname);
 809         if (!NT_STATUS_IS_OK(status)) {
 810                 return ERROR_NT(status);
 811         }
 812
 813         if (open_ofun == 0) {
 814                 return ERROR_NT(NT_STATUS_OBJECT_NAME_COLLISION);
 815         }
 816
 817         if (!map_open_params_to_ntcreate(fname, deny_mode, open_ofun,
 818                                 &access_mask,
 819                                 &share_mode,
 820                                 &create_disposition,
 821                                 &create_options)) {
 822                 return ERROR_DOS(ERRDOS, ERRbadaccess);
 823         }
 824
 825         /* Any data in this call is an EA list. */
 826         if (total_data && (total_data != 4) && !lp_ea_support(SNUM(conn))) {
 827                 return ERROR_NT(NT_STATUS_EAS_NOT_SUPPORTED);
 828         }
 829
 830         if (total_data != 4) {
 831                 if (total_data < 10) {
 832                         return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
 833                 }
 834
 835                 if (IVAL(pdata,0) > total_data) {
 836                         DEBUG(10,("call_trans2open: bad total data size (%u) > %u\n",
 837                                 IVAL(pdata,0), (unsigned int)total_data));
 838                         return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
 839                 }
 840
 841                 ea_list = read_ea_list(tmp_talloc_ctx(), pdata + 4,
 842                                        total_data - 4);
 843                 if (!ea_list) {
 844                         return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
 845                 }
 846         } else if (IVAL(pdata,0) != 4) {
 847                 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
 848         }
 849
 850         status = open_file_ntcreate(conn,fname,&sbuf,
 851                 access_mask,
 852                 share_mode,
 853                 create_disposition,
 854                 create_options,
 855                 open_attr,
 856                 oplock_request,
 857                 &smb_action, &fsp);
 858
 859         if (!NT_STATUS_IS_OK(status)) {
 860                 if (open_was_deferred(SVAL(inbuf,smb_mid))) {
 861                         /* We have re-scheduled this call. */
 862                         return -1;
 863                 }
 864                 return ERROR_NT(status);
 865         }
 866
 867         size = get_file_size(sbuf);
 868         fattr = dos_mode(conn,fname,&sbuf);
 869         mtime = sbuf.st_mtime;
 870         inode = sbuf.st_ino;
 871         if (fattr & aDIR) {
 872                 close_file(fsp,ERROR_CLOSE);
 873                 return(ERROR_DOS(ERRDOS,ERRnoaccess));
 874         }
 875
 876         /* Save the requested allocation size. */
 877         /* Allocate space for the file if a size hint is supplied */
 878         if ((smb_action == FILE_WAS_CREATED) || (smb_action == FILE_WAS_OVERWRITTEN)) {
 879                 SMB_BIG_UINT allocation_size = (SMB_BIG_UINT)open_size;
 880                 if (allocation_size && (allocation_size > (SMB_BIG_UINT)size)) {
 881                         fsp->initial_allocation_size = smb_roundup(fsp->conn, allocation_size);
 882                         if (fsp->is_directory) {
 883                                 close_file(fsp,ERROR_CLOSE);
 884                                 /* Can't set allocation size on a directory. */
 885                                 return ERROR_NT(NT_STATUS_ACCESS_DENIED);
 886                         }
 887                         if (vfs_allocate_file_space(fsp, fsp->initial_allocation_size) == -1) {
 888                                 close_file(fsp,ERROR_CLOSE);
 889                                 return ERROR_NT(NT_STATUS_DISK_FULL);
 890                         }
 891
 892                         /* Adjust size here to return the right size in the reply.
 893                            Windows does it this way. */
 894                         size = fsp->initial_allocation_size;
 895                 } else {
 896                         fsp->initial_allocation_size = smb_roundup(fsp->conn,(SMB_BIG_UINT)size);
 897                 }
 898         }
 899
 900         if (ea_list && smb_action == FILE_WAS_CREATED) {
 901                 status = set_ea(conn, fsp, fname, ea_list);
 902                 if (!NT_STATUS_IS_OK(status)) {
 903                         close_file(fsp,ERROR_CLOSE);
 904                         return ERROR_NT(status);
 905                 }
 906         }
 907
 908         /* Realloc the size of parameters and data we will return */
 909         *pparams = (char *)SMB_REALLOC(*pparams, 30);
 910         if(*pparams == NULL ) {
 911                 return ERROR_NT(NT_STATUS_NO_MEMORY);
 912         }
 913         params = *pparams;
 914
 915         SSVAL(params,0,fsp->fnum);
 916         SSVAL(params,2,fattr);
 917         srv_put_dos_date2(params,4, mtime);
 918         SIVAL(params,8, (uint32)size);
 919         SSVAL(params,12,deny_mode);
 920         SSVAL(params,14,0); /* open_type - file or directory. */
 921         SSVAL(params,16,0); /* open_state - only valid for IPC device. */
 922
 923         if (oplock_request && lp_fake_oplocks(SNUM(conn))) {
 924                 smb_action |= EXTENDED_OPLOCK_GRANTED;
 925         }
 926
 927         SSVAL(params,18,smb_action);
 928
 929         /*
 930          * WARNING - this may need to be changed if SMB_INO_T <> 4 bytes.
 931          */
 932         SIVAL(params,20,inode);
 933         SSVAL(params,24,0); /* Padding. */
 934         if (flags & 8) {
 935                 uint32 ea_size = estimate_ea_size(conn, fsp, fname);
 936                 SIVAL(params, 26, ea_size);
 937         } else {
 938                 SIVAL(params, 26, 0);
 939         }
 940
 941         /* Send the required number of replies */
 942         send_trans2_replies(outbuf, bufsize, params, 30, *ppdata, 0, max_data_bytes);
 943
 944         return -1;
 945 }
 946
 947 /*********************************************************
 948  Routine to check if a given string matches exactly.
 949  as a special case a mask of "." does NOT match. That
 950  is required for correct wildcard semantics
 951  Case can be significant or not.
 952 **********************************************************/
 953
 954 static BOOL exact_match(connection_struct *conn, char *str, char *mask)
 955 {
 956         if (mask[0] == '.' && mask[1] == 0)
 957                 return False;
 958         if (conn->case_sensitive)
 959                 return strcmp(str,mask)==0;
 960         if (StrCaseCmp(str,mask) != 0) {
 961                 return False;
 962         }
 963         if (dptr_has_wild(conn->dirptr)) {
 964                 return False;
 965         }
 966         return True;
 967 }
 968
 969 /****************************************************************************
 970  Return the filetype for UNIX extensions.
 971 ****************************************************************************/
 972
 973 static uint32 unix_filetype(mode_t mode)
 974 {
 975         if(S_ISREG(mode))
 976                 return UNIX_TYPE_FILE;
 977         else if(S_ISDIR(mode))
 978                 return UNIX_TYPE_DIR;
 979 #ifdef S_ISLNK
 980         else if(S_ISLNK(mode))
 981                 return UNIX_TYPE_SYMLINK;
 982 #endif
 983 #ifdef S_ISCHR
 984         else if(S_ISCHR(mode))
 985                 return UNIX_TYPE_CHARDEV;
 986 #endif
 987 #ifdef S_ISBLK
 988         else if(S_ISBLK(mode))
 989                 return UNIX_TYPE_BLKDEV;
 990 #endif
 991 #ifdef S_ISFIFO
 992         else if(S_ISFIFO(mode))
 993                 return UNIX_TYPE_FIFO;
 994 #endif
 995 #ifdef S_ISSOCK
 996         else if(S_ISSOCK(mode))
 997                 return UNIX_TYPE_SOCKET;
 998 #endif
 999
1000         DEBUG(0,("unix_filetype: unknown filetype %u", (unsigned)mode));
1001         return UNIX_TYPE_UNKNOWN;
1002 }
1003
1004 /****************************************************************************
1005  Map wire perms onto standard UNIX permissions. Obey share restrictions.
1006 ****************************************************************************/
1007
1008 static mode_t unix_perms_from_wire( connection_struct *conn, SMB_STRUCT_STAT *pst, uint32 perms)
1009 {
1010         mode_t ret = 0;
1011
1012         if (perms == SMB_MODE_NO_CHANGE)
1013                 return pst->st_mode;
1014
1015         ret |= ((perms & UNIX_X_OTH ) ? S_IXOTH : 0);
1016         ret |= ((perms & UNIX_W_OTH ) ? S_IWOTH : 0);
1017         ret |= ((perms & UNIX_R_OTH ) ? S_IROTH : 0);
1018         ret |= ((perms & UNIX_X_GRP ) ? S_IXGRP : 0);
1019         ret |= ((perms & UNIX_W_GRP ) ? S_IWGRP : 0);
1020         ret |= ((perms & UNIX_R_GRP ) ? S_IRGRP : 0);
1021         ret |= ((perms & UNIX_X_USR ) ? S_IXUSR : 0);
1022         ret |= ((perms & UNIX_W_USR ) ? S_IWUSR : 0);
1023         ret |= ((perms & UNIX_R_USR ) ? S_IRUSR : 0);
1024 #ifdef S_ISVTX
1025         ret |= ((perms & UNIX_STICKY ) ? S_ISVTX : 0);
1026 #endif
1027 #ifdef S_ISGID
1028         ret |= ((perms & UNIX_SET_GID ) ? S_ISGID : 0);
1029 #endif
1030 #ifdef S_ISUID
1031         ret |= ((perms & UNIX_SET_UID ) ? S_ISUID : 0);
1032 #endif
1033
1034         if (VALID_STAT(*pst) && S_ISDIR(pst->st_mode)) {
1035                 ret &= lp_dir_mask(SNUM(conn));
1036                 /* Add in force bits */
1037                 ret |= lp_force_dir_mode(SNUM(conn));
1038         } else {
1039                 /* Apply mode mask */
1040                 ret &= lp_create_mask(SNUM(conn));
1041                 /* Add in force bits */
1042                 ret |= lp_force_create_mode(SNUM(conn));
1043         }
1044
1045         return ret;
1046 }
1047
1048 /****************************************************************************
1049  Get a level dependent lanman2 dir entry.
1050 ****************************************************************************/
1051
1052 static BOOL get_lanman2_dir_entry(connection_struct *conn,
1053                                   void *inbuf, char *outbuf,
1054                                  char *path_mask,uint32 dirtype,int info_level,
1055                                  int requires_resume_key,
1056                                  BOOL dont_descend,char **ppdata,
1057                                  char *base_data, int space_remaining,
1058                                  BOOL *out_of_space, BOOL *got_exact_match,
1059                                  int *last_entry_off, struct ea_list *name_list, TALLOC_CTX *ea_ctx)
1060 {
1061         const char *dname;
1062         BOOL found = False;
1063         SMB_STRUCT_STAT sbuf;
1064         pstring mask;
1065         pstring pathreal;
1066         pstring fname;
1067         char *p, *q, *pdata = *ppdata;
1068         uint32 reskey=0;
1069         long prev_dirpos=0;
1070         uint32 mode=0;
1071         SMB_OFF_T file_size = 0;
1072         SMB_BIG_UINT allocation_size = 0;
1073         uint32 len;
1074         struct timespec mdate_ts, adate_ts, create_date_ts;
1075         time_t mdate = (time_t)0, adate = (time_t)0, create_date = (time_t)0;
1076         char *nameptr;
1077         char *last_entry_ptr;
1078         BOOL was_8_3;
1079         uint32 nt_extmode; /* Used for NT connections instead of mode */
1080         BOOL needslash = ( conn->dirpath[strlen(conn->dirpath) -1] != '/');
1081         BOOL check_mangled_names = lp_manglednames(conn->params);
1082
1083         *fname = 0;
1084         *out_of_space = False;
1085         *got_exact_match = False;
1086
1087         ZERO_STRUCT(mdate_ts);
1088         ZERO_STRUCT(adate_ts);
1089         ZERO_STRUCT(create_date_ts);
1090
1091         if (!conn->dirptr)
1092                 return(False);
1093
1094         p = strrchr_m(path_mask,'/');
1095         if(p != NULL) {
1096                 if(p[1] == '\0')
1097                         pstrcpy(mask,"*.*");
1098                 else
1099                         pstrcpy(mask, p+1);
1100         } else
1101                 pstrcpy(mask, path_mask);
1102
1103
1104         while (!found) {
1105                 BOOL got_match;
1106                 BOOL ms_dfs_link = False;
1107
1108                 /* Needed if we run out of space */
1109                 long curr_dirpos = prev_dirpos = dptr_TellDir(conn->dirptr);
1110                 dname = dptr_ReadDirName(conn->dirptr,&curr_dirpos,&sbuf);
1111
1112                 /*
1113                  * Due to bugs in NT client redirectors we are not using
1114                  * resume keys any more - set them to zero.
1115                  * Check out the related comments in findfirst/findnext.
1116                  * JRA.
1117                  */
1118
1119                 reskey = 0;
1120
1121                 DEBUG(8,("get_lanman2_dir_entry:readdir on dirptr 0x%lx now at offset %ld\n",
1122                         (long)conn->dirptr,curr_dirpos));
1123
1124                 if (!dname)
1125                         return(False);
1126
1127                 pstrcpy(fname,dname);
1128
1129                 if(!(got_match = *got_exact_match = exact_match(conn, fname, mask)))
1130                         got_match = mask_match(fname, mask, conn->case_sensitive);
1131
1132                 if(!got_match && check_mangled_names &&
1133                    !mangle_is_8_3(fname, False, conn->params)) {
1134
1135                         /*
1136                          * It turns out that NT matches wildcards against
1137                          * both long *and* short names. This may explain some
1138                          * of the wildcard wierdness from old DOS clients
1139                          * that some people have been seeing.... JRA.
1140                          */
1141
1142                         pstring newname;
1143                         pstrcpy( newname, fname);
1144                         mangle_map( newname, True, False, conn->params);
1145                         if(!(got_match = *got_exact_match = exact_match(conn, newname, mask)))
1146                                 got_match = mask_match(newname, mask, conn->case_sensitive);
1147                 }
1148
1149                 if(got_match) {
1150                         BOOL isdots = (strequal(fname,"..") || strequal(fname,"."));
1151                         if (dont_descend && !isdots)
1152                                 continue;
1153
1154                         pstrcpy(pathreal,conn->dirpath);
1155                         if(needslash)
1156                                 pstrcat(pathreal,"/");
1157                         pstrcat(pathreal,dname);
1158
1159                         if (INFO_LEVEL_IS_UNIX(info_level)) {
1160                                 if (SMB_VFS_LSTAT(conn,pathreal,&sbuf) != 0) {
1161                                         DEBUG(5,("get_lanman2_dir_entry:Couldn't lstat [%s] (%s)\n",
1162                                                 pathreal,strerror(errno)));
1163                                         continue;
1164                                 }
1165                         } else if (!VALID_STAT(sbuf) && SMB_VFS_STAT(conn,pathreal,&sbuf) != 0) {
1166
1167                                 /* Needed to show the msdfs symlinks as
1168                                  * directories */
1169
1170                                 if(lp_host_msdfs() &&
1171                                    lp_msdfs_root(SNUM(conn)) &&
1172                                    ((ms_dfs_link = is_msdfs_link(NULL,conn, pathreal, NULL, NULL, &sbuf)) == True)) {
1173
1174                                         DEBUG(5,("get_lanman2_dir_entry: Masquerading msdfs link %s as a directory\n", pathreal));
1175                                         sbuf.st_mode = (sbuf.st_mode & 0xFFF) | S_IFDIR;
1176
1177                                 } else {
1178
1179                                         DEBUG(5,("get_lanman2_dir_entry:Couldn't stat [%s] (%s)\n",
1180                                                 pathreal,strerror(errno)));
1181                                         continue;
1182                                 }
1183                         }
1184
1185                         if (ms_dfs_link) {
1186                                 mode = dos_mode_msdfs(conn,pathreal,&sbuf);
1187                         } else {
1188                                 mode = dos_mode(conn,pathreal,&sbuf);
1189                         }
1190
1191                         if (!dir_check_ftype(conn,mode,dirtype)) {
1192                                 DEBUG(5,("[%s] attribs didn't match %x\n",fname,dirtype));
1193                                 continue;
1194                         }
1195
1196                         if (!(mode & aDIR))
1197                                 file_size = get_file_size(sbuf);
1198                         allocation_size = get_allocation_size(conn,NULL,&sbuf);
1199
1200                         mdate_ts = get_mtimespec(&sbuf);
1201                         adate_ts = get_atimespec(&sbuf);
1202                         create_date_ts = get_create_timespec(&sbuf,lp_fake_dir_create_times(SNUM(conn)));
1203
1204                         if (lp_dos_filetime_resolution(SNUM(conn))) {
1205                                 dos_filetime_timespec(&create_date_ts);
1206                                 dos_filetime_timespec(&mdate_ts);
1207                                 dos_filetime_timespec(&adate_ts);
1208                         }
1209
1210                         create_date = convert_timespec_to_time_t(create_date_ts);
1211                         mdate = convert_timespec_to_time_t(mdate_ts);
1212                         adate = convert_timespec_to_time_t(adate_ts);
1213
1214                         DEBUG(5,("get_lanman2_dir_entry found %s fname=%s\n",pathreal,fname));
1215
1216                         found = True;
1217
1218                         dptr_DirCacheAdd(conn->dirptr, dname, curr_dirpos);
1219                 }
1220         }
1221
1222         mangle_map(fname,False,True,conn->params);
1223
1224         p = pdata;
1225         last_entry_ptr = p;
1226
1227         nt_extmode = mode ? mode : FILE_ATTRIBUTE_NORMAL;
1228
1229         switch (info_level) {
1230                 case SMB_FIND_INFO_STANDARD:
1231                         DEBUG(10,("get_lanman2_dir_entry: SMB_FIND_INFO_STANDARD\n"));
1232                         if(requires_resume_key) {
1233                                 SIVAL(p,0,reskey);
1234                                 p += 4;
1235                         }
1236                         srv_put_dos_date2(p,0,create_date);
1237                         srv_put_dos_date2(p,4,adate);
1238                         srv_put_dos_date2(p,8,mdate);
1239                         SIVAL(p,12,(uint32)file_size);
1240                         SIVAL(p,16,(uint32)allocation_size);
1241                         SSVAL(p,20,mode);
1242                         p += 23;
1243                         nameptr = p;
1244                         p += align_string(outbuf, p, 0);
1245                         len = srvstr_push(outbuf, p, fname, -1, STR_TERMINATE);
1246                         if (SVAL(outbuf, smb_flg2) & FLAGS2_UNICODE_STRINGS) {
1247                                 if (len > 2) {
1248                                         SCVAL(nameptr, -1, len - 2);
1249                                 } else {
1250                                         SCVAL(nameptr, -1, 0);
1251                                 }
1252                         } else {
1253                                 if (len > 1) {
1254                                         SCVAL(nameptr, -1, len - 1);
1255                                 } else {
1256                                         SCVAL(nameptr, -1, 0);
1257                                 }
1258                         }
1259                         p += len;
1260                         break;
1261
1262                 case SMB_FIND_EA_SIZE:
1263                         DEBUG(10,("get_lanman2_dir_entry: SMB_FIND_EA_SIZE\n"));
1264                         if(requires_resume_key) {
1265                                 SIVAL(p,0,reskey);
1266                                 p += 4;
1267                         }
1268                         srv_put_dos_date2(p,0,create_date);
1269                         srv_put_dos_date2(p,4,adate);
1270                         srv_put_dos_date2(p,8,mdate);
1271                         SIVAL(p,12,(uint32)file_size);
1272                         SIVAL(p,16,(uint32)allocation_size);
1273                         SSVAL(p,20,mode);
1274                         {
1275                                 unsigned int ea_size = estimate_ea_size(conn, NULL, pathreal);
1276                                 SIVAL(p,22,ea_size); /* Extended attributes */
1277                         }
1278                         p += 27;
1279                         nameptr = p - 1;
1280                         len = srvstr_push(outbuf, p, fname, -1, STR_TERMINATE | STR_NOALIGN);
1281                         if (SVAL(outbuf, smb_flg2) & FLAGS2_UNICODE_STRINGS) {
1282                                 if (len > 2) {
1283                                         len -= 2;
1284                                 } else {
1285                                         len = 0;
1286                                 }
1287                         } else {
1288                                 if (len > 1) {
1289                                         len -= 1;
1290                                 } else {
1291                                         len = 0;
1292                                 }
1293                         }
1294                         SCVAL(nameptr,0,len);
1295                         p += len;
1296                         SCVAL(p,0,0); p += 1; /* Extra zero byte ? - why.. */
1297                         break;
1298
1299                 case SMB_FIND_EA_LIST:
1300                 {
1301                         struct ea_list *file_list = NULL;
1302                         size_t ea_len = 0;
1303
1304                         DEBUG(10,("get_lanman2_dir_entry: SMB_FIND_EA_LIST\n"));
1305                         if (!name_list) {
1306                                 return False;
1307                         }
1308                         if(requires_resume_key) {
1309                                 SIVAL(p,0,reskey);
1310                                 p += 4;
1311                         }
1312                         srv_put_dos_date2(p,0,create_date);
1313                         srv_put_dos_date2(p,4,adate);
1314                         srv_put_dos_date2(p,8,mdate);
1315                         SIVAL(p,12,(uint32)file_size);
1316                         SIVAL(p,16,(uint32)allocation_size);
1317                         SSVAL(p,20,mode);
1318                         p += 22; /* p now points to the EA area. */
1319
1320                         file_list = get_ea_list_from_file(ea_ctx, conn, NULL, pathreal, &ea_len);
1321                         name_list = ea_list_union(name_list, file_list, &ea_len);
1322
1323                         /* We need to determine if this entry will fit in the space available. */
1324                         /* Max string size is 255 bytes. */
1325                         if (PTR_DIFF(p + 255 + ea_len,pdata) > space_remaining) {
1326                                 /* Move the dirptr back to prev_dirpos */
1327                                 dptr_SeekDir(conn->dirptr, prev_dirpos);
1328                                 *out_of_space = True;
1329                                 DEBUG(9,("get_lanman2_dir_entry: out of space\n"));
1330                                 return False; /* Not finished - just out of space */
1331                         }
1332
1333                         /* Push the ea_data followed by the name. */
1334                         p += fill_ea_buffer(ea_ctx, p, space_remaining, conn, name_list);
1335                         nameptr = p;
1336                         len = srvstr_push(outbuf, p + 1, fname, -1, STR_TERMINATE | STR_NOALIGN);
1337                         if (SVAL(outbuf, smb_flg2) & FLAGS2_UNICODE_STRINGS) {
1338                                 if (len > 2) {
1339                                         len -= 2;
1340                                 } else {
1341                                         len = 0;
1342                                 }
1343                         } else {
1344                                 if (len > 1) {
1345                                         len -= 1;
1346                                 } else {
1347                                         len = 0;
1348                                 }
1349                         }
1350                         SCVAL(nameptr,0,len);
1351                         p += len + 1;
1352                         SCVAL(p,0,0); p += 1; /* Extra zero byte ? - why.. */
1353                         break;
1354                 }
1355
1356                 case SMB_FIND_FILE_BOTH_DIRECTORY_INFO:
1357                         DEBUG(10,("get_lanman2_dir_entry: SMB_FIND_FILE_BOTH_DIRECTORY_INFO\n"));
1358                         was_8_3 = mangle_is_8_3(fname, True, conn->params);
1359                         p += 4;
1360                         SIVAL(p,0,reskey); p += 4;
1361                         put_long_date_timespec(p,create_date_ts); p += 8;
1362                         put_long_date_timespec(p,adate_ts); p += 8;
1363                         put_long_date_timespec(p,mdate_ts); p += 8;
1364                         put_long_date_timespec(p,mdate_ts); p += 8;
1365                         SOFF_T(p,0,file_size); p += 8;
1366                         SOFF_T(p,0,allocation_size); p += 8;
1367                         SIVAL(p,0,nt_extmode); p += 4;
1368                         q = p; p += 4; /* q is placeholder for name length. */
1369                         {
1370                                 unsigned int ea_size = estimate_ea_size(conn, NULL, pathreal);
1371                                 SIVAL(p,0,ea_size); /* Extended attributes */
1372                                 p += 4;
1373                         }
1374                         /* Clear the short name buffer. This is
1375                          * IMPORTANT as not doing so will trigger
1376                          * a Win2k client bug. JRA.
1377                          */
1378                         if (!was_8_3 && check_mangled_names) {
1379                                 pstring mangled_name;
1380                                 pstrcpy(mangled_name, fname);
1381                                 mangle_map(mangled_name,True,True,
1382                                            conn->params);
1383                                 mangled_name[12] = 0;
1384                                 len = srvstr_push(outbuf, p+2, mangled_name, 24, STR_UPPER|STR_UNICODE);
1385                                 if (len < 24) {
1386                                         memset(p + 2 + len,'\0',24 - len);
1387                                 }
1388                                 SSVAL(p, 0, len);
1389                         } else {
1390                                 memset(p,'\0',26);
1391                         }
1392                         p += 2 + 24;
1393                         len = srvstr_push(outbuf, p, fname, -1, STR_TERMINATE_ASCII);
1394                         SIVAL(q,0,len);
1395                         p += len;
1396                         SIVAL(p,0,0); /* Ensure any padding is null. */
1397                         len = PTR_DIFF(p, pdata);
1398                         len = (len + 3) & ~3;
1399                         SIVAL(pdata,0,len);
1400                         p = pdata + len;
1401                         break;
1402
1403                 case SMB_FIND_FILE_DIRECTORY_INFO:
1404                         DEBUG(10,("get_lanman2_dir_entry: SMB_FIND_FILE_DIRECTORY_INFO\n"));
1405                         p += 4;
1406                         SIVAL(p,0,reskey); p += 4;
1407                         put_long_date_timespec(p,create_date_ts); p += 8;
1408                         put_long_date_timespec(p,adate_ts); p += 8;
1409                         put_long_date_timespec(p,mdate_ts); p += 8;
1410                         put_long_date_timespec(p,mdate_ts); p += 8;
1411                         SOFF_T(p,0,file_size); p += 8;
1412                         SOFF_T(p,0,allocation_size); p += 8;
1413                         SIVAL(p,0,nt_extmode); p += 4;
1414                         len = srvstr_push(outbuf, p + 4, fname, -1, STR_TERMINATE_ASCII);
1415                         SIVAL(p,0,len);
1416                         p += 4 + len;
1417                         SIVAL(p,0,0); /* Ensure any padding is null. */
1418                         len = PTR_DIFF(p, pdata);
1419                         len = (len + 3) & ~3;
1420                         SIVAL(pdata,0,len);
1421                         p = pdata + len;
1422                         break;
1423
1424                 case SMB_FIND_FILE_FULL_DIRECTORY_INFO:
1425                         DEBUG(10,("get_lanman2_dir_entry: SMB_FIND_FILE_FULL_DIRECTORY_INFO\n"));
1426                         p += 4;
1427                         SIVAL(p,0,reskey); p += 4;
1428                         put_long_date_timespec(p,create_date_ts); p += 8;
1429                         put_long_date_timespec(p,adate_ts); p += 8;
1430                         put_long_date_timespec(p,mdate_ts); p += 8;
1431                         put_long_date_timespec(p,mdate_ts); p += 8;
1432                         SOFF_T(p,0,file_size); p += 8;
1433                         SOFF_T(p,0,allocation_size); p += 8;
1434                         SIVAL(p,0,nt_extmode); p += 4;
1435                         q = p; p += 4; /* q is placeholder for name length. */
1436                         {
1437                                 unsigned int ea_size = estimate_ea_size(conn, NULL, pathreal);
1438                                 SIVAL(p,0,ea_size); /* Extended attributes */
1439                                 p +=4;
1440                         }
1441                         len = srvstr_push(outbuf, p, fname, -1, STR_TERMINATE_ASCII);
1442                         SIVAL(q, 0, len);
1443                         p += len;
1444
1445                         SIVAL(p,0,0); /* Ensure any padding is null. */
1446                         len = PTR_DIFF(p, pdata);
1447                         len = (len + 3) & ~3;
1448                         SIVAL(pdata,0,len);
1449                         p = pdata + len;
1450                         break;
1451
1452                 case SMB_FIND_FILE_NAMES_INFO:
1453                         DEBUG(10,("get_lanman2_dir_entry: SMB_FIND_FILE_NAMES_INFO\n"));
1454                         p += 4;
1455                         SIVAL(p,0,reskey); p += 4;
1456                         p += 4;
1457                         /* this must *not* be null terminated or w2k gets in a loop trying to set an
1458                            acl on a dir (tridge) */
1459                         len = srvstr_push(outbuf, p, fname, -1, STR_TERMINATE_ASCII);
1460                         SIVAL(p, -4, len);
1461                         p += len;
1462                         SIVAL(p,0,0); /* Ensure any padding is null. */
1463                         len = PTR_DIFF(p, pdata);
1464                         len = (len + 3) & ~3;
1465                         SIVAL(pdata,0,len);
1466                         p = pdata + len;
1467                         break;
1468
1469                 case SMB_FIND_ID_FULL_DIRECTORY_INFO:
1470                         DEBUG(10,("get_lanman2_dir_entry: SMB_FIND_ID_FULL_DIRECTORY_INFO\n"));
1471                         p += 4;
1472                         SIVAL(p,0,reskey); p += 4;
1473                         put_long_date_timespec(p,create_date_ts); p += 8;
1474                         put_long_date_timespec(p,adate_ts); p += 8;
1475                         put_long_date_timespec(p,mdate_ts); p += 8;
1476                         put_long_date_timespec(p,mdate_ts); p += 8;
1477                         SOFF_T(p,0,file_size); p += 8;
1478                         SOFF_T(p,0,allocation_size); p += 8;
1479                         SIVAL(p,0,nt_extmode); p += 4;
1480                         q = p; p += 4; /* q is placeholder for name length. */
1481                         {
1482                                 unsigned int ea_size = estimate_ea_size(conn, NULL, pathreal);
1483                                 SIVAL(p,0,ea_size); /* Extended attributes */
1484                                 p +=4;
1485                         }
1486                         SIVAL(p,0,0); p += 4; /* Unknown - reserved ? */
1487                         SIVAL(p,0,sbuf.st_ino); p += 4; /* FileIndexLow */
1488                         SIVAL(p,0,sbuf.st_dev); p += 4; /* FileIndexHigh */
1489                         len = srvstr_push(outbuf, p, fname, -1, STR_TERMINATE_ASCII);
1490                         SIVAL(q, 0, len);
1491                         p += len;
1492                         SIVAL(p,0,0); /* Ensure any padding is null. */
1493                         len = PTR_DIFF(p, pdata);
1494                         len = (len + 3) & ~3;
1495                         SIVAL(pdata,0,len);
1496                         p = pdata + len;
1497                         break;
1498
1499                 case SMB_FIND_ID_BOTH_DIRECTORY_INFO:
1500                         DEBUG(10,("get_lanman2_dir_entry: SMB_FIND_ID_BOTH_DIRECTORY_INFO\n"));
1501                         was_8_3 = mangle_is_8_3(fname, True, conn->params);
1502                         p += 4;
1503                         SIVAL(p,0,reskey); p += 4;
1504                         put_long_date_timespec(p,create_date_ts); p += 8;
1505                         put_long_date_timespec(p,adate_ts); p += 8;
1506                         put_long_date_timespec(p,mdate_ts); p += 8;
1507                         put_long_date_timespec(p,mdate_ts); p += 8;
1508                         SOFF_T(p,0,file_size); p += 8;
1509                         SOFF_T(p,0,allocation_size); p += 8;
1510                         SIVAL(p,0,nt_extmode); p += 4;
1511                         q = p; p += 4; /* q is placeholder for name length */
1512                         {
1513                                 unsigned int ea_size = estimate_ea_size(conn, NULL, pathreal);
1514                                 SIVAL(p,0,ea_size); /* Extended attributes */
1515                                 p +=4;
1516                         }
1517                         /* Clear the short name buffer. This is
1518                          * IMPORTANT as not doing so will trigger
1519                          * a Win2k client bug. JRA.
1520                          */
1521                         if (!was_8_3 && check_mangled_names) {
1522                                 pstring mangled_name;
1523                                 pstrcpy(mangled_name, fname);
1524                                 mangle_map(mangled_name,True,True,
1525                                            conn->params);
1526                                 mangled_name[12] = 0;
1527                                 len = srvstr_push(outbuf, p+2, mangled_name, 24, STR_UPPER|STR_UNICODE);
1528                                 SSVAL(p, 0, len);
1529                                 if (len < 24) {
1530                                         memset(p + 2 + len,'\0',24 - len);
1531                                 }
1532                                 SSVAL(p, 0, len);
1533                         } else {
1534                                 memset(p,'\0',26);
1535                         }
1536                         p += 26;
1537                         SSVAL(p,0,0); p += 2; /* Reserved ? */
1538                         SIVAL(p,0,sbuf.st_ino); p += 4; /* FileIndexLow */
1539                         SIVAL(p,0,sbuf.st_dev); p += 4; /* FileIndexHigh */
1540                         len = srvstr_push(outbuf, p, fname, -1, STR_TERMINATE_ASCII);
1541                         SIVAL(q,0,len);
1542                         p += len;
1543                         SIVAL(p,0,0); /* Ensure any padding is null. */
1544                         len = PTR_DIFF(p, pdata);
1545                         len = (len + 3) & ~3;
1546                         SIVAL(pdata,0,len);
1547                         p = pdata + len;
1548                         break;
1549
1550                 /* CIFS UNIX Extension. */
1551
1552                 case SMB_FIND_FILE_UNIX:
1553                         DEBUG(10,("get_lanman2_dir_entry: SMB_FIND_FILE_UNIX\n"));
1554                         p+= 4;
1555                         SIVAL(p,0,reskey); p+= 4;    /* Used for continuing search. */
1556
1557                         /* Begin of SMB_QUERY_FILE_UNIX_BASIC */
1558                         SOFF_T(p,0,get_file_size(sbuf));             /* File size 64 Bit */
1559                         p+= 8;
1560
1561                         SOFF_T(p,0,get_allocation_size(conn,NULL,&sbuf)); /* Number of bytes used on disk - 64 Bit */
1562                         p+= 8;
1563
1564                         put_long_date_timespec(p,get_ctimespec(&sbuf));       /* Inode change Time 64 Bit */
1565                         put_long_date_timespec(p+8,get_atimespec(&sbuf));     /* Last access time 64 Bit */
1566                         put_long_date_timespec(p+16,get_mtimespec(&sbuf));    /* Last modification time 64 Bit */
1567                         p+= 24;
1568
1569                         SIVAL(p,0,sbuf.st_uid);               /* user id for the owner */
1570                         SIVAL(p,4,0);
1571                         p+= 8;
1572
1573                         SIVAL(p,0,sbuf.st_gid);               /* group id of owner */
1574                         SIVAL(p,4,0);
1575                         p+= 8;
1576
1577                         SIVAL(p,0,unix_filetype(sbuf.st_mode));
1578                         p+= 4;
1579
1580                         SIVAL(p,0,unix_dev_major(sbuf.st_rdev));   /* Major device number if type is device */
1581                         SIVAL(p,4,0);
1582                         p+= 8;
1583
1584                         SIVAL(p,0,unix_dev_minor(sbuf.st_rdev));   /* Minor device number if type is device */
1585                         SIVAL(p,4,0);
1586                         p+= 8;
1587
1588                         SINO_T_VAL(p,0,(SMB_INO_T)sbuf.st_ino);   /* inode number */
1589                         p+= 8;
1590
1591                         SIVAL(p,0, unix_perms_to_wire(sbuf.st_mode));     /* Standard UNIX file permissions */
1592                         SIVAL(p,4,0);
1593                         p+= 8;
1594
1595                         SIVAL(p,0,sbuf.st_nlink);             /* number of hard links */
1596                         SIVAL(p,4,0);
1597                         p+= 8;
1598
1599                         len = srvstr_push(outbuf, p, fname, -1, STR_TERMINATE);
1600                         p += len;
1601                         SIVAL(p,0,0); /* Ensure any padding is null. */
1602
1603                         len = PTR_DIFF(p, pdata);
1604                         len = (len + 3) & ~3;
1605                         SIVAL(pdata,0,len);     /* Offset from this structure to the beginning of the next one */
1606                         p = pdata + len;
1607                         /* End of SMB_QUERY_FILE_UNIX_BASIC */
1608
1609                         break;
1610
1611                 default:
1612                         return(False);
1613         }
1614
1615
1616         if (PTR_DIFF(p,pdata) > space_remaining) {
1617                 /* Move the dirptr back to prev_dirpos */
1618                 dptr_SeekDir(conn->dirptr, prev_dirpos);
1619                 *out_of_space = True;
1620                 DEBUG(9,("get_lanman2_dir_entry: out of space\n"));
1621                 return False; /* Not finished - just out of space */
1622         }
1623
1624         /* Setup the last entry pointer, as an offset from base_data */
1625         *last_entry_off = PTR_DIFF(last_entry_ptr,base_data);
1626         /* Advance the data pointer to the next slot */
1627         *ppdata = p;
1628
1629         return(found);
1630 }
1631
1632 /****************************************************************************
1633  Reply to a TRANS2_FINDFIRST.
1634 ****************************************************************************/
1635
1636 static int call_trans2findfirst(connection_struct *conn, char *inbuf, char *outbuf, int bufsize,
1637                                 char **pparams, int total_params, char **ppdata, int total_data,
1638                                 unsigned int max_data_bytes)
1639 {
1640         /* We must be careful here that we don't return more than the
1641                 allowed number of data bytes. If this means returning fewer than
1642                 maxentries then so be it. We assume that the redirector has
1643                 enough room for the fixed number of parameter bytes it has
1644                 requested. */
1645         char *params = *pparams;
1646         char *pdata = *ppdata;
1647         uint32 dirtype;
1648         int maxentries;
1649         uint16 findfirst_flags;
1650         BOOL close_after_first;
1651         BOOL close_if_end;
1652         BOOL requires_resume_key;
1653         int info_level;
1654         pstring directory;
1655         pstring mask;
1656         char *p;
1657         int last_entry_off=0;
1658         int dptr_num = -1;
1659         int numentries = 0;
1660         int i;
1661         BOOL finished = False;
1662         BOOL dont_descend = False;
1663         BOOL out_of_space = False;
1664         int space_remaining;
1665         BOOL mask_contains_wcard = False;
1666         SMB_STRUCT_STAT sbuf;
1667         TALLOC_CTX *ea_ctx = NULL;
1668         struct ea_list *ea_list = NULL;
1669         NTSTATUS ntstatus = NT_STATUS_OK;
1670
1671         if (total_params < 13) {
1672                 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
1673         }
1674
1675         dirtype = SVAL(params,0);
1676         maxentries = SVAL(params,2);
1677         findfirst_flags = SVAL(params,4);
1678         close_after_first = (findfirst_flags & FLAG_TRANS2_FIND_CLOSE);
1679         close_if_end = (findfirst_flags & FLAG_TRANS2_FIND_CLOSE_IF_END);
1680         requires_resume_key = (findfirst_flags & FLAG_TRANS2_FIND_REQUIRE_RESUME);
1681         info_level = SVAL(params,6);
1682
1683         *directory = *mask = 0;
1684
1685         DEBUG(3,("call_trans2findfirst: dirtype = %x, maxentries = %d, close_after_first=%d, \
1686 close_if_end = %d requires_resume_key = %d level = 0x%x, max_data_bytes = %d\n",
1687                 (unsigned int)dirtype, maxentries, close_after_first, close_if_end, requires_resume_key,
1688                 info_level, max_data_bytes));
1689
1690         if (!maxentries) {
1691                 /* W2K3 seems to treat zero as 1. */
1692                 maxentries = 1;
1693         }
1694
1695         switch (info_level) {
1696                 case SMB_FIND_INFO_STANDARD:
1697                 case SMB_FIND_EA_SIZE:
1698                 case SMB_FIND_EA_LIST:
1699                 case SMB_FIND_FILE_DIRECTORY_INFO:
1700                 case SMB_FIND_FILE_FULL_DIRECTORY_INFO:
1701                 case SMB_FIND_FILE_NAMES_INFO:
1702                 case SMB_FIND_FILE_BOTH_DIRECTORY_INFO:
1703                 case SMB_FIND_ID_FULL_DIRECTORY_INFO:
1704                 case SMB_FIND_ID_BOTH_DIRECTORY_INFO:
1705                         break;
1706                 case SMB_FIND_FILE_UNIX:
1707                         if (!lp_unix_extensions()) {
1708                                 return ERROR_NT(NT_STATUS_INVALID_LEVEL);
1709                         }
1710                         break;
1711                 default:
1712                         return ERROR_NT(NT_STATUS_INVALID_LEVEL);
1713         }
1714
1715         srvstr_get_path_wcard(inbuf, directory, params+12, sizeof(directory), total_params - 12, STR_TERMINATE, &ntstatus, &mask_contains_wcard);
1716         if (!NT_STATUS_IS_OK(ntstatus)) {
1717                 return ERROR_NT(ntstatus);
1718         }
1719
1720         RESOLVE_DFSPATH_WCARD(directory, conn, inbuf, outbuf);
1721
1722         ntstatus = unix_convert(conn, directory, True, NULL, &sbuf);
1723         if (!NT_STATUS_IS_OK(ntstatus)) {
1724                 return ERROR_NT(ntstatus);
1725         }
1726         ntstatus = check_name(conn, directory);
1727         if (!NT_STATUS_IS_OK(ntstatus)) {
1728                 return ERROR_NT(ntstatus);
1729         }
1730
1731         p = strrchr_m(directory,'/');
1732         if(p == NULL) {
1733                 /* Windows and OS/2 systems treat search on the root '\' as if it were '\*' */
1734                 if((directory[0] == '.') && (directory[1] == '\0')) {
1735                         pstrcpy(mask,"*");
1736                         mask_contains_wcard = True;
1737                 } else {
1738                         pstrcpy(mask,directory);
1739                 }
1740                 pstrcpy(directory,"./");
1741         } else {
1742                 pstrcpy(mask,p+1);
1743                 *p = 0;
1744         }
1745
1746         DEBUG(5,("dir=%s, mask = %s\n",directory, mask));
1747
1748         if (info_level == SMB_FIND_EA_LIST) {
1749                 uint32 ea_size;
1750
1751                 if (total_data < 4) {
1752                         return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
1753                 }
1754
1755                 ea_size = IVAL(pdata,0);
1756                 if (ea_size != total_data) {
1757                         DEBUG(4,("call_trans2findfirst: Rejecting EA request with incorrect \
1758 total_data=%u (should be %u)\n", (unsigned int)total_data, (unsigned int)IVAL(pdata,0) ));
1759                         return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
1760                 }
1761
1762                 if (!lp_ea_support(SNUM(conn))) {
1763                         return ERROR_DOS(ERRDOS,ERReasnotsupported);
1764                 }
1765
1766                 if ((ea_ctx = talloc_init("findnext_ea_list")) == NULL) {
1767                         return ERROR_NT(NT_STATUS_NO_MEMORY);
1768                 }
1769
1770                 /* Pull out the list of names. */
1771                 ea_list = read_ea_name_list(ea_ctx, pdata + 4, ea_size - 4);
1772                 if (!ea_list) {
1773                         talloc_destroy(ea_ctx);
1774                         return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
1775                 }
1776         }
1777
1778         *ppdata = (char *)SMB_REALLOC(
1779                 *ppdata, max_data_bytes + DIR_ENTRY_SAFETY_MARGIN);
1780         if(*ppdata == NULL ) {
1781                 talloc_destroy(ea_ctx);
1782                 return ERROR_NT(NT_STATUS_NO_MEMORY);
1783         }
1784         pdata = *ppdata;
1785
1786         /* Realloc the params space */
1787         *pparams = (char *)SMB_REALLOC(*pparams, 10);
1788         if (*pparams == NULL) {
1789                 talloc_destroy(ea_ctx);
1790                 return ERROR_NT(NT_STATUS_NO_MEMORY);
1791         }
1792         params = *pparams;
1793
1794         /* Save the wildcard match and attribs we are using on this directory -
1795                 needed as lanman2 assumes these are being saved between calls */
1796
1797         ntstatus = dptr_create(conn,
1798                                 directory,
1799                                 False,
1800                                 True,
1801                                 SVAL(inbuf,smb_pid),
1802                                 mask,
1803                                 mask_contains_wcard,
1804                                 dirtype,
1805                                 &conn->dirptr);
1806
1807         if (!NT_STATUS_IS_OK(ntstatus)) {
1808                 talloc_destroy(ea_ctx);
1809                 return ERROR_NT(ntstatus);
1810         }
1811
1812         dptr_num = dptr_dnum(conn->dirptr);
1813         DEBUG(4,("dptr_num is %d, wcard = %s, attr = %d\n", dptr_num, mask, dirtype));
1814
1815         /* We don't need to check for VOL here as this is returned by
1816                 a different TRANS2 call. */
1817
1818         DEBUG(8,("dirpath=<%s> dontdescend=<%s>\n", conn->dirpath,lp_dontdescend(SNUM(conn))));
1819         if (in_list(conn->dirpath,lp_dontdescend(SNUM(conn)),conn->case_sensitive))
1820                 dont_descend = True;
1821
1822         p = pdata;
1823         space_remaining = max_data_bytes;
1824         out_of_space = False;
1825
1826         for (i=0;(i<maxentries) && !finished && !out_of_space;i++) {
1827                 BOOL got_exact_match = False;
1828
1829                 /* this is a heuristic to avoid seeking the dirptr except when
1830                         absolutely necessary. It allows for a filename of about 40 chars */
1831                 if (space_remaining < DIRLEN_GUESS && numentries > 0) {
1832                         out_of_space = True;
1833                         finished = False;
1834                 } else {
1835                         finished = !get_lanman2_dir_entry(conn,
1836                                         inbuf, outbuf,
1837                                         mask,dirtype,info_level,
1838                                         requires_resume_key,dont_descend,
1839                                         &p,pdata,space_remaining, &out_of_space, &got_exact_match,
1840                                         &last_entry_off, ea_list, ea_ctx);
1841                 }
1842
1843                 if (finished && out_of_space)
1844                         finished = False;
1845
1846                 if (!finished && !out_of_space)
1847                         numentries++;
1848
1849                 /*
1850                  * As an optimisation if we know we aren't looking
1851                  * for a wildcard name (ie. the name matches the wildcard exactly)
1852                  * then we can finish on any (first) match.
1853                  * This speeds up large directory searches. JRA.
1854                  */
1855
1856                 if(got_exact_match)
1857                         finished = True;
1858
1859                 space_remaining = max_data_bytes - PTR_DIFF(p,pdata);
1860         }
1861
1862         talloc_destroy(ea_ctx);
1863
1864         /* Check if we can close the dirptr */
1865         if(close_after_first || (finished && close_if_end)) {
1866                 DEBUG(5,("call_trans2findfirst - (2) closing dptr_num %d\n", dptr_num));
1867                 dptr_close(&dptr_num);
1868         }
1869
1870         /*
1871          * If there are no matching entries we must return ERRDOS/ERRbadfile -
1872          * from observation of NT. NB. This changes to ERRDOS,ERRnofiles if
1873          * the protocol level is less than NT1. Tested with smbclient. JRA.
1874          * This should fix the OS/2 client bug #2335.
1875          */
1876
1877         if(numentries == 0) {
1878                 dptr_close(&dptr_num);
1879                 if (Protocol < PROTOCOL_NT1) {
1880                         return ERROR_DOS(ERRDOS,ERRnofiles);
1881                 } else {
1882                         return ERROR_BOTH(NT_STATUS_NO_SUCH_FILE,ERRDOS,ERRbadfile);
1883                 }
1884         }
1885
1886         /* At this point pdata points to numentries directory entries. */
1887
1888         /* Set up the return parameter block */
1889         SSVAL(params,0,dptr_num);
1890         SSVAL(params,2,numentries);
1891         SSVAL(params,4,finished);
1892         SSVAL(params,6,0); /* Never an EA error */
1893         SSVAL(params,8,last_entry_off);
1894
1895         send_trans2_replies( outbuf, bufsize, params, 10, pdata, PTR_DIFF(p,pdata), max_data_bytes);
1896
1897         if ((! *directory) && dptr_path(dptr_num))
1898                 slprintf(directory,sizeof(directory)-1, "(%s)",dptr_path(dptr_num));
1899
1900         DEBUG( 4, ( "%s mask=%s directory=%s dirtype=%d numentries=%d\n",
1901                 smb_fn_name(CVAL(inbuf,smb_com)),
1902                 mask, directory, dirtype, numentries ) );
1903
1904         /*
1905          * Force a name mangle here to ensure that the
1906          * mask as an 8.3 name is top of the mangled cache.
1907          * The reasons for this are subtle. Don't remove
1908          * this code unless you know what you are doing
1909          * (see PR#13758). JRA.
1910          */
1911
1912         if(!mangle_is_8_3_wildcards( mask, False, conn->params))
1913                 mangle_map(mask, True, True, conn->params);
1914
1915         return(-1);
1916 }
1917
1918 /****************************************************************************
1919  Reply to a TRANS2_FINDNEXT.
1920 ****************************************************************************/
1921
1922 static int call_trans2findnext(connection_struct *conn, char *inbuf, char *outbuf, int length, int bufsize,
1923                                         char **pparams, int total_params, char **ppdata, int total_data,
1924                                         unsigned int max_data_bytes)
1925 {
1926         /* We must be careful here that we don't return more than the
1927                 allowed number of data bytes. If this means returning fewer than
1928                 maxentries then so be it. We assume that the redirector has
1929                 enough room for the fixed number of parameter bytes it has
1930                 requested. */
1931         char *params = *pparams;
1932         char *pdata = *ppdata;
1933         int dptr_num;
1934         int maxentries;
1935         uint16 info_level;
1936         uint32 resume_key;
1937         uint16 findnext_flags;
1938         BOOL close_after_request;
1939         BOOL close_if_end;
1940         BOOL requires_resume_key;
1941         BOOL continue_bit;
1942         BOOL mask_contains_wcard = False;
1943         pstring resume_name;
1944         pstring mask;
1945         pstring directory;
1946         char *p;
1947         uint16 dirtype;
1948         int numentries = 0;
1949         int i, last_entry_off=0;
1950         BOOL finished = False;
1951         BOOL dont_descend = False;
1952         BOOL out_of_space = False;
1953         int space_remaining;
1954         TALLOC_CTX *ea_ctx = NULL;
1955         struct ea_list *ea_list = NULL;
1956         NTSTATUS ntstatus = NT_STATUS_OK;
1957
1958         if (total_params < 13) {
1959                 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
1960         }
1961
1962         dptr_num = SVAL(params,0);
1963         maxentries = SVAL(params,2);
1964         info_level = SVAL(params,4);
1965         resume_key = IVAL(params,6);
1966         findnext_flags = SVAL(params,10);
1967         close_after_request = (findnext_flags & FLAG_TRANS2_FIND_CLOSE);
1968         close_if_end = (findnext_flags & FLAG_TRANS2_FIND_CLOSE_IF_END);
1969         requires_resume_key = (findnext_flags & FLAG_TRANS2_FIND_REQUIRE_RESUME);
1970         continue_bit = (findnext_flags & FLAG_TRANS2_FIND_CONTINUE);
1971
1972         *mask = *directory = *resume_name = 0;
1973
1974         srvstr_get_path_wcard(inbuf, resume_name, params+12, sizeof(resume_name), total_params - 12, STR_TERMINATE, &ntstatus, &mask_contains_wcard);
1975         if (!NT_STATUS_IS_OK(ntstatus)) {
1976                 /* Win9x or OS/2 can send a resume name of ".." or ".". This will cause the parser to
1977                    complain (it thinks we're asking for the directory above the shared
1978                    path or an invalid name). Catch this as the resume name is only compared, never used in
1979                    a file access. JRA. */
1980                 if (NT_STATUS_EQUAL(ntstatus,NT_STATUS_OBJECT_PATH_SYNTAX_BAD)) {
1981                         pstrcpy(resume_name, "..");
1982                 } else if (NT_STATUS_EQUAL(ntstatus,NT_STATUS_OBJECT_NAME_INVALID)) {
1983                         pstrcpy(resume_name, ".");
1984                 } else {
1985                         return ERROR_NT(ntstatus);
1986                 }
1987         }
1988
1989         DEBUG(3,("call_trans2findnext: dirhandle = %d, max_data_bytes = %d, maxentries = %d, \
1990 close_after_request=%d, close_if_end = %d requires_resume_key = %d \
1991 resume_key = %d resume name = %s continue=%d level = %d\n",
1992                 dptr_num, max_data_bytes, maxentries, close_after_request, close_if_end,
1993                 requires_resume_key, resume_key, resume_name, continue_bit, info_level));
1994
1995         if (!maxentries) {
1996                 /* W2K3 seems to treat zero as 1. */
1997                 maxentries = 1;
1998         }
1999
2000         switch (info_level) {
2001                 case SMB_FIND_INFO_STANDARD:
2002                 case SMB_FIND_EA_SIZE:
2003                 case SMB_FIND_EA_LIST:
2004                 case SMB_FIND_FILE_DIRECTORY_INFO:
2005                 case SMB_FIND_FILE_FULL_DIRECTORY_INFO:
2006                 case SMB_FIND_FILE_NAMES_INFO:
2007                 case SMB_FIND_FILE_BOTH_DIRECTORY_INFO:
2008                 case SMB_FIND_ID_FULL_DIRECTORY_INFO:
2009                 case SMB_FIND_ID_BOTH_DIRECTORY_INFO:
2010                         break;
2011                 case SMB_FIND_FILE_UNIX:
2012                         if (!lp_unix_extensions()) {
2013                                 return ERROR_NT(NT_STATUS_INVALID_LEVEL);
2014                         }
2015                         break;
2016                 default:
2017                         return ERROR_NT(NT_STATUS_INVALID_LEVEL);
2018         }
2019
2020         if (info_level == SMB_FIND_EA_LIST) {
2021                 uint32 ea_size;
2022
2023                 if (total_data < 4) {
2024                         return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
2025                 }
2026
2027                 ea_size = IVAL(pdata,0);
2028                 if (ea_size != total_data) {
2029                         DEBUG(4,("call_trans2findnext: Rejecting EA request with incorrect \
2030 total_data=%u (should be %u)\n", (unsigned int)total_data, (unsigned int)IVAL(pdata,0) ));
2031                         return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
2032                 }
2033
2034                 if (!lp_ea_support(SNUM(conn))) {
2035                         return ERROR_DOS(ERRDOS,ERReasnotsupported);
2036                 }
2037
2038                 if ((ea_ctx = talloc_init("findnext_ea_list")) == NULL) {
2039                         return ERROR_NT(NT_STATUS_NO_MEMORY);
2040                 }
2041
2042                 /* Pull out the list of names. */
2043                 ea_list = read_ea_name_list(ea_ctx, pdata + 4, ea_size - 4);
2044                 if (!ea_list) {
2045                         talloc_destroy(ea_ctx);
2046                         return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
2047                 }
2048         }
2049
2050         *ppdata = (char *)SMB_REALLOC(
2051                 *ppdata, max_data_bytes + DIR_ENTRY_SAFETY_MARGIN);
2052         if(*ppdata == NULL) {
2053                 talloc_destroy(ea_ctx);
2054                 return ERROR_NT(NT_STATUS_NO_MEMORY);
2055         }
2056
2057         pdata = *ppdata;
2058
2059         /* Realloc the params space */
2060         *pparams = (char *)SMB_REALLOC(*pparams, 6*SIZEOFWORD);
2061         if(*pparams == NULL ) {
2062                 talloc_destroy(ea_ctx);
2063                 return ERROR_NT(NT_STATUS_NO_MEMORY);
2064         }
2065
2066         params = *pparams;
2067
2068         /* Check that the dptr is valid */
2069         if(!(conn->dirptr = dptr_fetch_lanman2(dptr_num))) {
2070                 talloc_destroy(ea_ctx);
2071                 return ERROR_DOS(ERRDOS,ERRnofiles);
2072         }
2073
2074         string_set(&conn->dirpath,dptr_path(dptr_num));
2075
2076         /* Get the wildcard mask from the dptr */
2077         if((p = dptr_wcard(dptr_num))== NULL) {
2078                 DEBUG(2,("dptr_num %d has no wildcard\n", dptr_num));
2079                 talloc_destroy(ea_ctx);
2080                 return ERROR_DOS(ERRDOS,ERRnofiles);
2081         }
2082
2083         pstrcpy(mask, p);
2084         pstrcpy(directory,conn->dirpath);
2085
2086         /* Get the attr mask from the dptr */
2087         dirtype = dptr_attr(dptr_num);
2088
2089         DEBUG(3,("dptr_num is %d, mask = %s, attr = %x, dirptr=(0x%lX,%ld)\n",
2090                 dptr_num, mask, dirtype,
2091                 (long)conn->dirptr,
2092                 dptr_TellDir(conn->dirptr)));
2093
2094         /* We don't need to check for VOL here as this is returned by
2095                 a different TRANS2 call. */
2096
2097         DEBUG(8,("dirpath=<%s> dontdescend=<%s>\n",conn->dirpath,lp_dontdescend(SNUM(conn))));
2098         if (in_list(conn->dirpath,lp_dontdescend(SNUM(conn)),conn->case_sensitive))
2099                 dont_descend = True;
2100
2101         p = pdata;
2102         space_remaining = max_data_bytes;
2103         out_of_space = False;
2104
2105         /*
2106          * Seek to the correct position. We no longer use the resume key but
2107          * depend on the last file name instead.
2108          */
2109
2110         if(*resume_name && !continue_bit) {
2111                 SMB_STRUCT_STAT st;
2112
2113                 long current_pos = 0;
2114                 /*
2115                  * Remember, mangle_map is called by
2116                  * get_lanman2_dir_entry(), so the resume name
2117                  * could be mangled. Ensure we check the unmangled name.
2118                  */
2119
2120                 if (mangle_is_mangled(resume_name, conn->params)) {
2121                         mangle_check_cache(resume_name, sizeof(resume_name)-1,
2122                                            conn->params);
2123                 }
2124
2125                 /*
2126                  * Fix for NT redirector problem triggered by resume key indexes
2127                  * changing between directory scans. We now return a resume key of 0
2128                  * and instead look for the filename to continue from (also given
2129                  * to us by NT/95/smbfs/smbclient). If no other scans have been done between the
2130                  * findfirst/findnext (as is usual) then the directory pointer
2131                  * should already be at the correct place.
2132                  */
2133
2134                 finished = !dptr_SearchDir(conn->dirptr, resume_name, &current_pos, &st);
2135         } /* end if resume_name && !continue_bit */
2136
2137         for (i=0;(i<(int)maxentries) && !finished && !out_of_space ;i++) {
2138                 BOOL got_exact_match = False;
2139
2140                 /* this is a heuristic to avoid seeking the dirptr except when
2141                         absolutely necessary. It allows for a filename of about 40 chars */
2142                 if (space_remaining < DIRLEN_GUESS && numentries > 0) {
2143                         out_of_space = True;
2144                         finished = False;
2145                 } else {
2146                         finished = !get_lanman2_dir_entry(conn,
2147                                                 inbuf, outbuf,
2148                                                 mask,dirtype,info_level,
2149                                                 requires_resume_key,dont_descend,
2150                                                 &p,pdata,space_remaining, &out_of_space, &got_exact_match,
2151                                                 &last_entry_off, ea_list, ea_ctx);
2152                 }
2153
2154                 if (finished && out_of_space)
2155                         finished = False;
2156
2157                 if (!finished && !out_of_space)
2158                         numentries++;
2159
2160                 /*
2161                  * As an optimisation if we know we aren't looking
2162                  * for a wildcard name (ie. the name matches the wildcard exactly)
2163                  * then we can finish on any (first) match.
2164                  * This speeds up large directory searches. JRA.
2165                  */
2166
2167                 if(got_exact_match)
2168                         finished = True;
2169
2170                 space_remaining = max_data_bytes - PTR_DIFF(p,pdata);
2171         }
2172
2173         talloc_destroy(ea_ctx);
2174
2175         /* Check if we can close the dirptr */
2176         if(close_after_request || (finished && close_if_end)) {
2177                 DEBUG(5,("call_trans2findnext: closing dptr_num = %d\n", dptr_num));
2178                 dptr_close(&dptr_num); /* This frees up the saved mask */
2179         }
2180
2181         /* Set up the return parameter block */
2182         SSVAL(params,0,numentries);
2183         SSVAL(params,2,finished);
2184         SSVAL(params,4,0); /* Never an EA error */
2185         SSVAL(params,6,last_entry_off);
2186
2187         send_trans2_replies( outbuf, bufsize, params, 8, pdata, PTR_DIFF(p,pdata), max_data_bytes);
2188
2189         if ((! *directory) && dptr_path(dptr_num))
2190                 slprintf(directory,sizeof(directory)-1, "(%s)",dptr_path(dptr_num));
2191
2192         DEBUG( 3, ( "%s mask=%s directory=%s dirtype=%d numentries=%d\n",
2193                 smb_fn_name(CVAL(inbuf,smb_com)),
2194                 mask, directory, dirtype, numentries ) );
2195
2196         return(-1);
2197 }
2198
2199 /****************************************************************************
2200  Reply to a TRANS2_QFSINFO (query filesystem info).
2201 ****************************************************************************/
2202
2203 static int call_trans2qfsinfo(connection_struct *conn, char *inbuf, char *outbuf, int length, int bufsize,
2204                                         char **pparams, int total_params, char **ppdata, int total_data,
2205                                         unsigned int max_data_bytes)
2206 {
2207         char *pdata = *ppdata;
2208         char *params = *pparams;
2209         uint16 info_level;
2210         int data_len, len;
2211         SMB_STRUCT_STAT st;
2212         char *vname = volume_label(SNUM(conn));
2213         int snum = SNUM(conn);
2214         char *fstype = lp_fstype(SNUM(conn));
2215         int quota_flag = 0;
2216
2217         if (total_params < 2) {
2218                 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
2219         }
2220
2221         info_level = SVAL(params,0);
2222
2223         DEBUG(3,("call_trans2qfsinfo: level = %d\n", info_level));
2224
2225         if(SMB_VFS_STAT(conn,".",&st)!=0) {
2226                 DEBUG(2,("call_trans2qfsinfo: stat of . failed (%s)\n", strerror(errno)));
2227                 return ERROR_DOS(ERRSRV,ERRinvdevice);
2228         }
2229
2230         *ppdata = (char *)SMB_REALLOC(
2231                 *ppdata, max_data_bytes + DIR_ENTRY_SAFETY_MARGIN);
2232         if (*ppdata == NULL ) {
2233                 return ERROR_NT(NT_STATUS_NO_MEMORY);
2234         }
2235
2236         pdata = *ppdata;
2237         memset((char *)pdata,'\0',max_data_bytes + DIR_ENTRY_SAFETY_MARGIN);
2238
2239         switch (info_level) {
2240                 case SMB_INFO_ALLOCATION:
2241                 {
2242                         SMB_BIG_UINT dfree,dsize,bsize,block_size,sectors_per_unit,bytes_per_sector;
2243                         data_len = 18;
2244                         if (get_dfree_info(conn,".",False,&bsize,&dfree,&dsize) == (SMB_BIG_UINT)-1) {
2245                                 return(UNIXERROR(ERRHRD,ERRgeneral));
2246                         }
2247
2248                         block_size = lp_block_size(snum);
2249                         if (bsize < block_size) {
2250                                 SMB_BIG_UINT factor = block_size/bsize;
2251                                 bsize = block_size;
2252                                 dsize /= factor;
2253                                 dfree /= factor;
2254                         }
2255                         if (bsize > block_size) {
2256                                 SMB_BIG_UINT factor = bsize/block_size;
2257                                 bsize = block_size;
2258                                 dsize *= factor;
2259                                 dfree *= factor;
2260                         }
2261                         bytes_per_sector = 512;
2262                         sectors_per_unit = bsize/bytes_per_sector;
2263
2264                         DEBUG(5,("call_trans2qfsinfo : SMB_INFO_ALLOCATION id=%x, bsize=%u, cSectorUnit=%u, \
2265 cBytesSector=%u, cUnitTotal=%u, cUnitAvail=%d\n", (unsigned int)st.st_dev, (unsigned int)bsize, (unsigned int)sectors_per_unit,
2266                                 (unsigned int)bytes_per_sector, (unsigned int)dsize, (unsigned int)dfree));
2267
2268                         SIVAL(pdata,l1_idFileSystem,st.st_dev);
2269                         SIVAL(pdata,l1_cSectorUnit,sectors_per_unit);
2270                         SIVAL(pdata,l1_cUnit,dsize);
2271                         SIVAL(pdata,l1_cUnitAvail,dfree);
2272                         SSVAL(pdata,l1_cbSector,bytes_per_sector);
2273                         break;
2274                 }
2275
2276                 case SMB_INFO_VOLUME:
2277                         /* Return volume name */
2278                         /*
2279                          * Add volume serial number - hash of a combination of
2280                          * the called hostname and the service name.
2281                          */
2282                         SIVAL(pdata,0,str_checksum(lp_servicename(snum)) ^ (str_checksum(get_local_machine_name())<<16) );
2283                         /*
2284                          * Win2k3 and previous mess this up by sending a name length
2285                          * one byte short. I believe only older clients (OS/2 Win9x) use
2286                          * this call so try fixing this by adding a terminating null to
2287                          * the pushed string. The change here was adding the STR_TERMINATE. JRA.
2288                          */
2289                         len = srvstr_push(outbuf, pdata+l2_vol_szVolLabel, vname, -1, STR_NOALIGN|STR_TERMINATE);
2290                         SCVAL(pdata,l2_vol_cch,len);
2291                         data_len = l2_vol_szVolLabel + len;
2292                         DEBUG(5,("call_trans2qfsinfo : time = %x, namelen = %d, name = %s\n",
2293                                 (unsigned)st.st_ctime, len, vname));
2294                         break;
2295
2296                 case SMB_QUERY_FS_ATTRIBUTE_INFO:
2297                 case SMB_FS_ATTRIBUTE_INFORMATION:
2298
2299
2300 #if defined(HAVE_SYS_QUOTAS)
2301                         quota_flag = FILE_VOLUME_QUOTAS;
2302 #endif
2303
2304                         SIVAL(pdata,0,FILE_CASE_PRESERVED_NAMES|FILE_CASE_SENSITIVE_SEARCH|
2305                                 (lp_nt_acl_support(SNUM(conn)) ? FILE_PERSISTENT_ACLS : 0)|
2306                                 quota_flag); /* FS ATTRIBUTES */
2307
2308                         SIVAL(pdata,4,255); /* Max filename component length */
2309                         /* NOTE! the fstype must *not* be null terminated or win98 won't recognise it
2310                                 and will think we can't do long filenames */
2311                         len = srvstr_push(outbuf, pdata+12, fstype, -1, STR_UNICODE);
2312                         SIVAL(pdata,8,len);
2313                         data_len = 12 + len;
2314                         break;
2315
2316                 case SMB_QUERY_FS_LABEL_INFO:
2317                 case SMB_FS_LABEL_INFORMATION:
2318                         len = srvstr_push(outbuf, pdata+4, vname, -1, 0);
2319                         data_len = 4 + len;
2320                         SIVAL(pdata,0,len);
2321                         break;
2322
2323                 case SMB_QUERY_FS_VOLUME_INFO:
2324                 case SMB_FS_VOLUME_INFORMATION:
2325
2326                         /*
2327                          * Add volume serial number - hash of a combination of
2328                          * the called hostname and the service name.
2329                          */
2330                         SIVAL(pdata,8,str_checksum(lp_servicename(snum)) ^
2331                                 (str_checksum(get_local_machine_name())<<16));
2332
2333                         len = srvstr_push(outbuf, pdata+18, vname, -1, STR_UNICODE);
2334                         SIVAL(pdata,12,len);
2335                         data_len = 18+len;
2336                         DEBUG(5,("call_trans2qfsinfo : SMB_QUERY_FS_VOLUME_INFO namelen = %d, vol=%s serv=%s\n",
2337                                 (int)strlen(vname),vname, lp_servicename(snum)));
2338                         break;
2339
2340                 case SMB_QUERY_FS_SIZE_INFO:
2341                 case SMB_FS_SIZE_INFORMATION:
2342                 {
2343                         SMB_BIG_UINT dfree,dsize,bsize,block_size,sectors_per_unit,bytes_per_sector;
2344                         data_len = 24;
2345                         if (get_dfree_info(conn,".",False,&bsize,&dfree,&dsize) == (SMB_BIG_UINT)-1) {
2346                                 return(UNIXERROR(ERRHRD,ERRgeneral));
2347                         }
2348                         block_size = lp_block_size(snum);
2349                         if (bsize < block_size) {
2350                                 SMB_BIG_UINT factor = block_size/bsize;
2351                                 bsize = block_size;
2352                                 dsize /= factor;
2353                                 dfree /= factor;
2354                         }
2355                         if (bsize > block_size) {
2356                                 SMB_BIG_UINT factor = bsize/block_size;
2357                                 bsize = block_size;
2358                                 dsize *= factor;
2359                                 dfree *= factor;
2360                         }
2361                         bytes_per_sector = 512;
2362                         sectors_per_unit = bsize/bytes_per_sector;
2363                         DEBUG(5,("call_trans2qfsinfo : SMB_QUERY_FS_SIZE_INFO bsize=%u, cSectorUnit=%u, \
2364 cBytesSector=%u, cUnitTotal=%u, cUnitAvail=%d\n", (unsigned int)bsize, (unsigned int)sectors_per_unit,
2365                                 (unsigned int)bytes_per_sector, (unsigned int)dsize, (unsigned int)dfree));
2366                         SBIG_UINT(pdata,0,dsize);
2367                         SBIG_UINT(pdata,8,dfree);
2368                         SIVAL(pdata,16,sectors_per_unit);
2369                         SIVAL(pdata,20,bytes_per_sector);
2370                         break;
2371                 }
2372
2373                 case SMB_FS_FULL_SIZE_INFORMATION:
2374                 {
2375                         SMB_BIG_UINT dfree,dsize,bsize,block_size,sectors_per_unit,bytes_per_sector;
2376                         data_len = 32;
2377                         if (get_dfree_info(conn,".",False,&bsize,&dfree,&dsize) == (SMB_BIG_UINT)-1) {
2378                                 return(UNIXERROR(ERRHRD,ERRgeneral));
2379                         }
2380                         block_size = lp_block_size(snum);
2381                         if (bsize < block_size) {
2382                                 SMB_BIG_UINT factor = block_size/bsize;
2383                                 bsize = block_size;
2384                                 dsize /= factor;
2385                                 dfree /= factor;
2386                         }
2387                         if (bsize > block_size) {
2388                                 SMB_BIG_UINT factor = bsize/block_size;
2389                                 bsize = block_size;
2390                                 dsize *= factor;
2391                                 dfree *= factor;
2392                         }
2393                         bytes_per_sector = 512;
2394                         sectors_per_unit = bsize/bytes_per_sector;
2395                         DEBUG(5,("call_trans2qfsinfo : SMB_QUERY_FS_FULL_SIZE_INFO bsize=%u, cSectorUnit=%u, \
2396 cBytesSector=%u, cUnitTotal=%u, cUnitAvail=%d\n", (unsigned int)bsize, (unsigned int)sectors_per_unit,
2397                                 (unsigned int)bytes_per_sector, (unsigned int)dsize, (unsigned int)dfree));
2398                         SBIG_UINT(pdata,0,dsize); /* Total Allocation units. */
2399                         SBIG_UINT(pdata,8,dfree); /* Caller available allocation units. */
2400                         SBIG_UINT(pdata,16,dfree); /* Actual available allocation units. */
2401                         SIVAL(pdata,24,sectors_per_unit); /* Sectors per allocation unit. */
2402                         SIVAL(pdata,28,bytes_per_sector); /* Bytes per sector. */
2403                         break;
2404                 }
2405
2406                 case SMB_QUERY_FS_DEVICE_INFO:
2407                 case SMB_FS_DEVICE_INFORMATION:
2408                         data_len = 8;
2409                         SIVAL(pdata,0,0); /* dev type */
2410                         SIVAL(pdata,4,0); /* characteristics */
2411                         break;
2412
2413 #ifdef HAVE_SYS_QUOTAS
2414                 case SMB_FS_QUOTA_INFORMATION:
2415                 /*
2416                  * what we have to send --metze:
2417                  *
2418                  * Unknown1:            24 NULL bytes
2419                  * Soft Quota Treshold: 8 bytes seems like SMB_BIG_UINT or so
2420                  * Hard Quota Limit:    8 bytes seems like SMB_BIG_UINT or so
2421                  * Quota Flags:         2 byte :
2422                  * Unknown3:            6 NULL bytes
2423                  *
2424                  * 48 bytes total
2425                  *
2426                  * details for Quota Flags:
2427                  *
2428                  * 0x0020 Log Limit: log if the user exceeds his Hard Quota
2429                  * 0x0010 Log Warn:  log if the user exceeds his Soft Quota
2430                  * 0x0002 Deny Disk: deny disk access when the user exceeds his Hard Quota
2431                  * 0x0001 Enable Quotas: enable quota for this fs
2432                  *
2433                  */
2434                 {
2435                         /* we need to fake up a fsp here,
2436                          * because its not send in this call
2437                          */
2438                         files_struct fsp;
2439                         SMB_NTQUOTA_STRUCT quotas;
2440
2441                         ZERO_STRUCT(fsp);
2442                         ZERO_STRUCT(quotas);
2443
2444                         fsp.conn = conn;
2445                         fsp.fnum = -1;
2446
2447                         /* access check */
2448                         if (current_user.ut.uid != 0) {
2449                                 DEBUG(0,("set_user_quota: access_denied service [%s] user [%s]\n",
2450                                         lp_servicename(SNUM(conn)),conn->user));
2451                                 return ERROR_DOS(ERRDOS,ERRnoaccess);
2452                         }
2453
2454                         if (vfs_get_ntquota(&fsp, SMB_USER_FS_QUOTA_TYPE, NULL, &quotas)!=0) {
2455                                 DEBUG(0,("vfs_get_ntquota() failed for service [%s]\n",lp_servicename(SNUM(conn))));
2456                                 return ERROR_DOS(ERRSRV,ERRerror);
2457                         }
2458
2459                         data_len = 48;
2460
2461                         DEBUG(10,("SMB_FS_QUOTA_INFORMATION: for service [%s]\n",lp_servicename(SNUM(conn))));
2462
2463                         /* Unknown1 24 NULL bytes*/
2464                         SBIG_UINT(pdata,0,(SMB_BIG_UINT)0);
2465                         SBIG_UINT(pdata,8,(SMB_BIG_UINT)0);
2466                         SBIG_UINT(pdata,16,(SMB_BIG_UINT)0);
2467
2468                         /* Default Soft Quota 8 bytes */
2469                         SBIG_UINT(pdata,24,quotas.softlim);
2470
2471                         /* Default Hard Quota 8 bytes */
2472                         SBIG_UINT(pdata,32,quotas.hardlim);
2473
2474                         /* Quota flag 2 bytes */
2475                         SSVAL(pdata,40,quotas.qflags);
2476
2477                         /* Unknown3 6 NULL bytes */
2478                         SSVAL(pdata,42,0);
2479                         SIVAL(pdata,44,0);
2480
2481                         break;
2482                 }
2483 #endif /* HAVE_SYS_QUOTAS */
2484                 case SMB_FS_OBJECTID_INFORMATION:
2485                         data_len = 64;
2486                         break;
2487
2488                 /*
2489                  * Query the version and capabilities of the CIFS UNIX extensions
2490                  * in use.
2491                  */
2492
2493                 case SMB_QUERY_CIFS_UNIX_INFO:
2494                         if (!lp_unix_extensions()) {
2495                                 return ERROR_NT(NT_STATUS_INVALID_LEVEL);
2496                         }
2497                         data_len = 12;
2498                         SSVAL(pdata,0,CIFS_UNIX_MAJOR_VERSION);
2499                         SSVAL(pdata,2,CIFS_UNIX_MINOR_VERSION);
2500                         /* We have POSIX ACLs, pathname and locking capability. */
2501                         SBIG_UINT(pdata,4,((SMB_BIG_UINT)(
2502                                         CIFS_UNIX_POSIX_ACLS_CAP|
2503                                         CIFS_UNIX_POSIX_PATHNAMES_CAP|
2504                                         CIFS_UNIX_FCNTL_LOCKS_CAP)));
2505                         break;
2506
2507                 case SMB_QUERY_POSIX_FS_INFO:
2508                 {
2509                         int rc;
2510                         vfs_statvfs_struct svfs;
2511
2512                         if (!lp_unix_extensions()) {
2513                                 return ERROR_NT(NT_STATUS_INVALID_LEVEL);
2514                         }
2515
2516                         rc = SMB_VFS_STATVFS(conn, ".", &svfs);
2517
2518                         if (!rc) {
2519                                 data_len = 56;
2520                                 SIVAL(pdata,0,svfs.OptimalTransferSize);
2521                                 SIVAL(pdata,4,svfs.BlockSize);
2522                                 SBIG_UINT(pdata,8,svfs.TotalBlocks);
2523                                 SBIG_UINT(pdata,16,svfs.BlocksAvail);
2524                                 SBIG_UINT(pdata,24,svfs.UserBlocksAvail);
2525                                 SBIG_UINT(pdata,32,svfs.TotalFileNodes);
2526                                 SBIG_UINT(pdata,40,svfs.FreeFileNodes);
2527                                 SBIG_UINT(pdata,48,svfs.FsIdentifier);
2528                                 DEBUG(5,("call_trans2qfsinfo : SMB_QUERY_POSIX_FS_INFO succsessful\n"));
2529 #ifdef EOPNOTSUPP
2530                         } else if (rc == EOPNOTSUPP) {
2531                                 return ERROR_NT(NT_STATUS_INVALID_LEVEL);
2532 #endif /* EOPNOTSUPP */
2533                         } else {
2534                                 DEBUG(0,("vfs_statvfs() failed for service [%s]\n",lp_servicename(SNUM(conn))));
2535                                 return ERROR_DOS(ERRSRV,ERRerror);
2536                         }
2537                         break;
2538                 }
2539
2540                 case SMB_MAC_QUERY_FS_INFO:
2541                         /*
2542                          * Thursby MAC extension... ONLY on NTFS filesystems
2543                          * once we do streams then we don't need this
2544                          */
2545                         if (strequal(lp_fstype(SNUM(conn)),"NTFS")) {
2546                                 data_len = 88;
2547                                 SIVAL(pdata,84,0x100); /* Don't support mac... */
2548                                 break;
2549                         }
2550                         /* drop through */
2551                 default:
2552                         return ERROR_NT(NT_STATUS_INVALID_LEVEL);
2553         }
2554
2555
2556         send_trans2_replies( outbuf, bufsize, params, 0, pdata, data_len, max_data_bytes);
2557
2558         DEBUG( 4, ( "%s info_level = %d\n", smb_fn_name(CVAL(inbuf,smb_com)), info_level) );
2559
2560         return -1;
2561 }
2562
2563 /****************************************************************************
2564  Reply to a TRANS2_SETFSINFO (set filesystem info).
2565 ****************************************************************************/
2566
2567 static int call_trans2setfsinfo(connection_struct *conn, char *inbuf, char *outbuf, int length, int bufsize,
2568                                         char **pparams, int total_params, char **ppdata, int total_data,
2569                                         unsigned int max_data_bytes)
2570 {
2571         char *pdata = *ppdata;
2572         char *params = *pparams;
2573         uint16 info_level;
2574         int outsize;
2575
2576         DEBUG(10,("call_trans2setfsinfo: for service [%s]\n",lp_servicename(SNUM(conn))));
2577
2578         /*  */
2579         if (total_params < 4) {
2580                 DEBUG(0,("call_trans2setfsinfo: requires total_params(%d) >= 4 bytes!\n",
2581                         total_params));
2582                 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
2583         }
2584
2585         info_level = SVAL(params,2);
2586
2587         switch(info_level) {
2588                 case SMB_SET_CIFS_UNIX_INFO:
2589                         {
2590                                 uint16 client_unix_major;
2591                                 uint16 client_unix_minor;
2592                                 uint32 client_unix_cap_low;
2593                                 uint32 client_unix_cap_high;
2594
2595                                 if (!lp_unix_extensions()) {
2596                                         return ERROR_NT(NT_STATUS_INVALID_LEVEL);
2597                                 }
2598
2599                                 /* There should be 12 bytes of capabilities set. */
2600                                 if (total_data < 8) {
2601                                         return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
2602                                 }
2603                                 client_unix_major = SVAL(pdata,0);
2604                                 client_unix_minor = SVAL(pdata,2);
2605                                 client_unix_cap_low = IVAL(pdata,4);
2606                                 client_unix_cap_high = IVAL(pdata,8);
2607                                 /* Just print these values for now. */
2608                                 DEBUG(10,("call_trans2setfsinfo: set unix info. major = %u, minor = %u \
2609 cap_low = 0x%x, cap_high = 0x%x\n",
2610                                         (unsigned int)client_unix_major,
2611                                         (unsigned int)client_unix_minor,
2612                                         (unsigned int)client_unix_cap_low,
2613                                         (unsigned int)client_unix_cap_high ));
2614
2615                                 /* Here is where we must switch to posix pathname processing... */
2616                                 if (client_unix_cap_low & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
2617                                         lp_set_posix_pathnames();
2618                                         mangle_change_to_posix();
2619                                 }
2620
2621                                 if (client_unix_cap_low & CIFS_UNIX_FCNTL_LOCKS_CAP) {
2622                                         lp_set_posix_cifsx_locktype(POSIX_LOCK);
2623                                 }
2624                                 break;
2625                         }
2626                 case SMB_FS_QUOTA_INFORMATION:
2627                         {
2628                                 files_struct *fsp = NULL;
2629                                 SMB_NTQUOTA_STRUCT quotas;
2630
2631                                 ZERO_STRUCT(quotas);
2632
2633                                 /* access check */
2634                                 if ((current_user.ut.uid != 0)||!CAN_WRITE(conn)) {
2635                                         DEBUG(0,("set_user_quota: access_denied service [%s] user [%s]\n",
2636                                                 lp_servicename(SNUM(conn)),conn->user));
2637                                         return ERROR_DOS(ERRSRV,ERRaccess);
2638                                 }
2639
2640                                 /* note: normaly there're 48 bytes,
2641                                  * but we didn't use the last 6 bytes for now
2642                                  * --metze
2643                                  */
2644                                 fsp = file_fsp(params,0);
2645                                 if (!CHECK_NTQUOTA_HANDLE_OK(fsp,conn)) {
2646                                         DEBUG(3,("TRANSACT_GET_USER_QUOTA: no valid QUOTA HANDLE\n"));
2647                                         return ERROR_NT(NT_STATUS_INVALID_HANDLE);
2648                                 }
2649
2650                                 if (total_data < 42) {
2651                                         DEBUG(0,("call_trans2setfsinfo: SET_FS_QUOTA: requires total_data(%d) >= 42 bytes!\n",
2652                                                 total_data));
2653                                         return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
2654                                 }
2655
2656                                 /* unknown_1 24 NULL bytes in pdata*/
2657
2658                                 /* the soft quotas 8 bytes (SMB_BIG_UINT)*/
2659                                 quotas.softlim = (SMB_BIG_UINT)IVAL(pdata,24);
2660 #ifdef LARGE_SMB_OFF_T
2661                                 quotas.softlim |= (((SMB_BIG_UINT)IVAL(pdata,28)) << 32);
2662 #else /* LARGE_SMB_OFF_T */
2663                                 if ((IVAL(pdata,28) != 0)&&
2664                                         ((quotas.softlim != 0xFFFFFFFF)||
2665                                         (IVAL(pdata,28)!=0xFFFFFFFF))) {
2666                                         /* more than 32 bits? */
2667                                         return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
2668                                 }
2669 #endif /* LARGE_SMB_OFF_T */
2670
2671                                 /* the hard quotas 8 bytes (SMB_BIG_UINT)*/
2672                                 quotas.hardlim = (SMB_BIG_UINT)IVAL(pdata,32);
2673 #ifdef LARGE_SMB_OFF_T
2674                                 quotas.hardlim |= (((SMB_BIG_UINT)IVAL(pdata,36)) << 32);
2675 #else /* LARGE_SMB_OFF_T */
2676                                 if ((IVAL(pdata,36) != 0)&&
2677                                         ((quotas.hardlim != 0xFFFFFFFF)||
2678                                         (IVAL(pdata,36)!=0xFFFFFFFF))) {
2679                                         /* more than 32 bits? */
2680                                         return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
2681                                 }
2682 #endif /* LARGE_SMB_OFF_T */
2683
2684                                 /* quota_flags 2 bytes **/
2685                                 quotas.qflags = SVAL(pdata,40);
2686
2687                                 /* unknown_2 6 NULL bytes follow*/
2688
2689                                 /* now set the quotas */
2690                                 if (vfs_set_ntquota(fsp, SMB_USER_FS_QUOTA_TYPE, NULL, &quotas)!=0) {
2691                                         DEBUG(0,("vfs_set_ntquota() failed for service [%s]\n",lp_servicename(SNUM(conn))));
2692                                         return ERROR_DOS(ERRSRV,ERRerror);
2693                                 }
2694
2695                                 break;
2696                         }
2697                 default:
2698                         DEBUG(3,("call_trans2setfsinfo: unknown level (0x%X) not implemented yet.\n",
2699                                 info_level));
2700                         return ERROR_NT(NT_STATUS_INVALID_LEVEL);
2701                         break;
2702         }
2703
2704         /*
2705          * sending this reply works fine,
2706          * but I'm not sure it's the same
2707          * like windows do...
2708          * --metze
2709          */
2710         outsize = set_message(outbuf,10,0,True);
2711
2712         return outsize;
2713 }
2714
2715 #if defined(HAVE_POSIX_ACLS)
2716 /****************************************************************************
2717  Utility function to count the number of entries in a POSIX acl.
2718 ****************************************************************************/
2719
2720 static unsigned int count_acl_entries(connection_struct *conn, SMB_ACL_T posix_acl)
2721 {
2722         unsigned int ace_count = 0;
2723         int entry_id = SMB_ACL_FIRST_ENTRY;
2724         SMB_ACL_ENTRY_T entry;
2725
2726         while ( posix_acl && (SMB_VFS_SYS_ACL_GET_ENTRY(conn, posix_acl, entry_id, &entry) == 1)) {
2727                 /* get_next... */
2728                 if (entry_id == SMB_ACL_FIRST_ENTRY) {
2729                         entry_id = SMB_ACL_NEXT_ENTRY;
2730                 }
2731                 ace_count++;
2732         }
2733         return ace_count;
2734 }
2735
2736 /****************************************************************************
2737  Utility function to marshall a POSIX acl into wire format.
2738 ****************************************************************************/
2739
2740 static BOOL marshall_posix_acl(connection_struct *conn, char *pdata, SMB_STRUCT_STAT *pst, SMB_ACL_T posix_acl)
2741 {
2742         int entry_id = SMB_ACL_FIRST_ENTRY;
2743         SMB_ACL_ENTRY_T entry;
2744
2745         while ( posix_acl && (SMB_VFS_SYS_ACL_GET_ENTRY(conn, posix_acl, entry_id, &entry) == 1)) {
2746                 SMB_ACL_TAG_T tagtype;
2747                 SMB_ACL_PERMSET_T permset;
2748                 unsigned char perms = 0;
2749                 unsigned int own_grp;
2750
2751                 /* get_next... */
2752                 if (entry_id == SMB_ACL_FIRST_ENTRY) {
2753                         entry_id = SMB_ACL_NEXT_ENTRY;
2754                 }
2755
2756                 if (SMB_VFS_SYS_ACL_GET_TAG_TYPE(conn, entry, &tagtype) == -1) {
2757                         DEBUG(0,("marshall_posix_acl: SMB_VFS_SYS_ACL_GET_TAG_TYPE failed.\n"));
2758                         return False;
2759                 }
2760
2761                 if (SMB_VFS_SYS_ACL_GET_PERMSET(conn, entry, &permset) == -1) {
2762                         DEBUG(0,("marshall_posix_acl: SMB_VFS_SYS_ACL_GET_PERMSET failed.\n"));
2763                         return False;
2764                 }
2765
2766                 perms |= (SMB_VFS_SYS_ACL_GET_PERM(conn, permset, SMB_ACL_READ) ? SMB_POSIX_ACL_READ : 0);
2767                 perms |= (SMB_VFS_SYS_ACL_GET_PERM(conn, permset, SMB_ACL_WRITE) ? SMB_POSIX_ACL_WRITE : 0);
2768                 perms |= (SMB_VFS_SYS_ACL_GET_PERM(conn, permset, SMB_ACL_EXECUTE) ? SMB_POSIX_ACL_EXECUTE : 0);
2769
2770                 SCVAL(pdata,1,perms);
2771
2772                 switch (tagtype) {
2773                         case SMB_ACL_USER_OBJ:
2774                                 SCVAL(pdata,0,SMB_POSIX_ACL_USER_OBJ);
2775                                 own_grp = (unsigned int)pst->st_uid;
2776                                 SIVAL(pdata,2,own_grp);
2777                                 SIVAL(pdata,6,0);
2778                                 break;
2779                         case SMB_ACL_USER:
2780                                 {
2781                                         uid_t *puid = (uid_t *)SMB_VFS_SYS_ACL_GET_QUALIFIER(conn, entry);
2782                                         if (!puid) {
2783                                                 DEBUG(0,("marshall_posix_acl: SMB_VFS_SYS_ACL_GET_QUALIFIER failed.\n"));
2784                                         }
2785                                         own_grp = (unsigned int)*puid;
2786                                         SMB_VFS_SYS_ACL_FREE_QUALIFIER(conn, (void *)puid,tagtype);
2787                                         SCVAL(pdata,0,SMB_POSIX_ACL_USER);
2788                                         SIVAL(pdata,2,own_grp);
2789                                         SIVAL(pdata,6,0);
2790                                         break;
2791                                 }
2792                         case SMB_ACL_GROUP_OBJ:
2793                                 SCVAL(pdata,0,SMB_POSIX_ACL_GROUP_OBJ);
2794                                 own_grp = (unsigned int)pst->st_gid;
2795                                 SIVAL(pdata,2,own_grp);
2796                                 SIVAL(pdata,6,0);
2797                                 break;
2798                         case SMB_ACL_GROUP:
2799                                 {
2800                                         gid_t *pgid= (gid_t *)SMB_VFS_SYS_ACL_GET_QUALIFIER(conn, entry);
2801                                         if (!pgid) {
2802                                                 DEBUG(0,("marshall_posix_acl: SMB_VFS_SYS_ACL_GET_QUALIFIER failed.\n"));
2803                                         }
2804                                         own_grp = (unsigned int)*pgid;
2805                                         SMB_VFS_SYS_ACL_FREE_QUALIFIER(conn, (void *)pgid,tagtype);
2806                                         SCVAL(pdata,0,SMB_POSIX_ACL_GROUP);
2807                                         SIVAL(pdata,2,own_grp);
2808                                         SIVAL(pdata,6,0);
2809                                         break;
2810                                 }
2811                         case SMB_ACL_MASK:
2812                                 SCVAL(pdata,0,SMB_POSIX_ACL_MASK);
2813                                 SIVAL(pdata,2,0xFFFFFFFF);
2814                                 SIVAL(pdata,6,0xFFFFFFFF);
2815                                 break;
2816                         case SMB_ACL_OTHER:
2817                                 SCVAL(pdata,0,SMB_POSIX_ACL_OTHER);
2818                                 SIVAL(pdata,2,0xFFFFFFFF);
2819                                 SIVAL(pdata,6,0xFFFFFFFF);
2820                                 break;
2821                         default:
2822                                 DEBUG(0,("marshall_posix_acl: unknown tagtype.\n"));
2823                                 return False;
2824                 }
2825                 pdata += SMB_POSIX_ACL_ENTRY_SIZE;
2826         }
2827
2828         return True;
2829 }
2830 #endif
2831
2832 /****************************************************************************
2833  Reply to a TRANS2_QFILEPATHINFO or TRANSACT2_QFILEINFO (query file info by
2834  file name or file id).
2835 ****************************************************************************/
2836
2837 static int call_trans2qfilepathinfo(connection_struct *conn, char *inbuf, char *outbuf, int length, int bufsize,
2838                                         unsigned int tran_call,
2839                                         char **pparams, int total_params, char **ppdata, int total_data,
2840                                         unsigned int max_data_bytes)
2841 {
2842         char *params = *pparams;
2843         char *pdata = *ppdata;
2844         uint16 info_level;
2845         int mode=0;
2846         int nlink;
2847         SMB_OFF_T file_size=0;
2848         SMB_BIG_UINT allocation_size=0;
2849         unsigned int data_size = 0;
2850         unsigned int param_size = 2;
2851         SMB_STRUCT_STAT sbuf;
2852         pstring fname, dos_fname;
2853         char *fullpathname;
2854         char *base_name;
2855         char *p;
2856         SMB_OFF_T pos = 0;
2857         BOOL delete_pending = False;
2858         int len;
2859         time_t create_time, mtime, atime;
2860         struct timespec create_time_ts, mtime_ts, atime_ts;
2861         files_struct *fsp = NULL;
2862         TALLOC_CTX *data_ctx = NULL;
2863         struct ea_list *ea_list = NULL;
2864         uint32 access_mask = 0x12019F; /* Default - GENERIC_EXECUTE mapping from Windows */
2865         char *lock_data = NULL;
2866
2867         if (!params)
2868                 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
2869
2870         ZERO_STRUCT(sbuf);
2871
2872         if (tran_call == TRANSACT2_QFILEINFO) {
2873                 if (total_params < 4) {
2874                         return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
2875                 }
2876
2877                 fsp = file_fsp(params,0);
2878                 info_level = SVAL(params,2);
2879
2880                 DEBUG(3,("call_trans2qfilepathinfo: TRANSACT2_QFILEINFO: level = %d\n", info_level));
2881
2882                 if(fsp && (fsp->fake_file_handle)) {
2883                         /*
2884                          * This is actually for the QUOTA_FAKE_FILE --metze
2885                          */
2886
2887                         pstrcpy(fname, fsp->fsp_name);
2888                         /* We know this name is ok, it's already passed the checks. */
2889
2890                 } else if(fsp && (fsp->is_directory || fsp->fh->fd == -1)) {
2891                         /*
2892                          * This is actually a QFILEINFO on a directory
2893                          * handle (returned from an NT SMB). NT5.0 seems
2894                          * to do this call. JRA.
2895                          */
2896                         /* We know this name is ok, it's already passed the checks. */
2897                         pstrcpy(fname, fsp->fsp_name);
2898
2899                         if (INFO_LEVEL_IS_UNIX(info_level)) {
2900                                 /* Always do lstat for UNIX calls. */
2901                                 if (SMB_VFS_LSTAT(conn,fname,&sbuf)) {
2902                                         DEBUG(3,("call_trans2qfilepathinfo: SMB_VFS_LSTAT of %s failed (%s)\n",fname,strerror(errno)));
2903                                         return UNIXERROR(ERRDOS,ERRbadpath);
2904                                 }
2905                         } else if (SMB_VFS_STAT(conn,fname,&sbuf)) {
2906                                 DEBUG(3,("call_trans2qfilepathinfo: SMB_VFS_STAT of %s failed (%s)\n",fname,strerror(errno)));
2907                                 return UNIXERROR(ERRDOS,ERRbadpath);
2908                         }
2909
2910                         delete_pending = get_delete_on_close_flag(sbuf.st_dev, sbuf.st_ino);
2911                 } else {
2912                         /*
2913                          * Original code - this is an open file.
2914                          */
2915                         CHECK_FSP(fsp,conn);
2916
2917                         pstrcpy(fname, fsp->fsp_name);
2918                         if (SMB_VFS_FSTAT(fsp,fsp->fh->fd,&sbuf) != 0) {
2919                                 DEBUG(3,("fstat of fnum %d failed (%s)\n", fsp->fnum, strerror(errno)));
2920                                 return(UNIXERROR(ERRDOS,ERRbadfid));
2921                         }
2922                         pos = fsp->fh->position_information;
2923                         delete_pending = get_delete_on_close_flag(sbuf.st_dev, sbuf.st_ino);
2924                         access_mask = fsp->access_mask;
2925                 }
2926         } else {
2927                 NTSTATUS status = NT_STATUS_OK;
2928
2929                 /* qpathinfo */
2930                 if (total_params < 7) {
2931                         return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
2932                 }
2933
2934                 info_level = SVAL(params,0);
2935
2936                 DEBUG(3,("call_trans2qfilepathinfo: TRANSACT2_QPATHINFO: level = %d\n", info_level));
2937
2938                 srvstr_get_path(inbuf, fname, &params[6], sizeof(fname), total_params - 6, STR_TERMINATE, &status);
2939                 if (!NT_STATUS_IS_OK(status)) {
2940                         return ERROR_NT(status);
2941                 }
2942
2943                 RESOLVE_DFSPATH(fname, conn, inbuf, outbuf);
2944
2945                 status = unix_convert(conn, fname, False, NULL, &sbuf);
2946                 if (!NT_STATUS_IS_OK(status)) {
2947                         return ERROR_NT(status);
2948                 }
2949                 status = check_name(conn, fname);
2950                 if (!NT_STATUS_IS_OK(status)) {
2951                         DEBUG(3,("call_trans2qfilepathinfo: fileinfo of %s failed (%s)\n",fname,nt_errstr(status)));
2952                         return ERROR_NT(status);
2953                 }
2954
2955                 if (INFO_LEVEL_IS_UNIX(info_level)) {
2956                         /* Always do lstat for UNIX calls. */
2957                         if (SMB_VFS_LSTAT(conn,fname,&sbuf)) {
2958                                 DEBUG(3,("call_trans2qfilepathinfo: SMB_VFS_LSTAT of %s failed (%s)\n",fname,strerror(errno)));
2959                                 return UNIXERROR(ERRDOS,ERRbadpath);
2960                         }
2961                 } else if (!VALID_STAT(sbuf) && SMB_VFS_STAT(conn,fname,&sbuf) && (info_level != SMB_INFO_IS_NAME_VALID)) {
2962                         DEBUG(3,("call_trans2qfilepathinfo: SMB_VFS_STAT of %s failed (%s)\n",fname,strerror(errno)));
2963                         return UNIXERROR(ERRDOS,ERRbadpath);
2964                 }
2965
2966                 delete_pending = get_delete_on_close_flag(sbuf.st_dev, sbuf.st_ino);
2967                 if (delete_pending) {
2968                         return ERROR_NT(NT_STATUS_DELETE_PENDING);
2969                 }
2970         }
2971
2972         nlink = sbuf.st_nlink;
2973
2974         if ((nlink > 0) && S_ISDIR(sbuf.st_mode)) {
2975                 /* NTFS does not seem to count ".." */
2976                 nlink -= 1;
2977         }
2978
2979         if ((nlink > 0) && delete_pending) {
2980                 nlink -= 1;
2981         }
2982
2983         if (INFO_LEVEL_IS_UNIX(info_level) && !lp_unix_extensions()) {
2984                 return ERROR_NT(NT_STATUS_INVALID_LEVEL);
2985         }
2986
2987         DEBUG(3,("call_trans2qfilepathinfo %s (fnum = %d) level=%d call=%d total_data=%d\n",
2988                 fname,fsp ? fsp->fnum : -1, info_level,tran_call,total_data));
2989
2990         p = strrchr_m(fname,'/');
2991         if (!p)
2992                 base_name = fname;
2993         else
2994                 base_name = p+1;
2995
2996         mode = dos_mode(conn,fname,&sbuf);
2997         if (!mode)
2998                 mode = FILE_ATTRIBUTE_NORMAL;
2999
3000         fullpathname = fname;
3001         if (!(mode & aDIR))
3002                 file_size = get_file_size(sbuf);
3003
3004         /* Pull out any data sent here before we realloc. */
3005         switch (info_level) {
3006                 case SMB_INFO_QUERY_EAS_FROM_LIST:
3007                 {
3008                         /* Pull any EA list from the data portion. */
3009                         uint32 ea_size;
3010
3011                         if (total_data < 4) {
3012                                 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
3013                         }
3014                         ea_size = IVAL(pdata,0);
3015
3016                         if (total_data > 0 && ea_size != total_data) {
3017                                 DEBUG(4,("call_trans2qfilepathinfo: Rejecting EA request with incorrect \
3018 total_data=%u (should be %u)\n", (unsigned int)total_data, (unsigned int)IVAL(pdata,0) ));
3019                                 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
3020                         }
3021
3022                         if (!lp_ea_support(SNUM(conn))) {
3023                                 return ERROR_DOS(ERRDOS,ERReasnotsupported);
3024                         }
3025
3026                         if ((data_ctx = talloc_init("ea_list")) == NULL) {
3027                                 return ERROR_NT(NT_STATUS_NO_MEMORY);
3028                         }
3029
3030                         /* Pull out the list of names. */
3031                         ea_list = read_ea_name_list(data_ctx, pdata + 4, ea_size - 4);
3032                         if (!ea_list) {
3033                                 talloc_destroy(data_ctx);
3034                                 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
3035                         }
3036                         break;
3037                 }
3038
3039                 case SMB_QUERY_POSIX_LOCK:
3040                 {
3041                         if (fsp == NULL || fsp->fh->fd == -1) {
3042                                 return ERROR_NT(NT_STATUS_INVALID_HANDLE);
3043                         }
3044
3045                         if (total_data != POSIX_LOCK_DATA_SIZE) {
3046                                 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
3047                         }
3048
3049                         if ((data_ctx = talloc_init("lock_request")) == NULL) {
3050                                 return ERROR_NT(NT_STATUS_NO_MEMORY);
3051                         }
3052
3053                         /* Copy the lock range data. */
3054                         lock_data = (char *)talloc_memdup(
3055                                 data_ctx, pdata, total_data);
3056                         if (!lock_data) {
3057                                 talloc_destroy(data_ctx);
3058                                 return ERROR_NT(NT_STATUS_NO_MEMORY);
3059                         }
3060                 }
3061                 default:
3062                         break;
3063         }
3064
3065         *pparams = (char *)SMB_REALLOC(*pparams,2);
3066         if (*pparams == NULL) {
3067                 talloc_destroy(data_ctx);
3068                 return ERROR_NT(NT_STATUS_NO_MEMORY);
3069         }
3070         params = *pparams;
3071         SSVAL(params,0,0);
3072         data_size = max_data_bytes + DIR_ENTRY_SAFETY_MARGIN;
3073         *ppdata = (char *)SMB_REALLOC(*ppdata, data_size);
3074         if (*ppdata == NULL ) {
3075                 talloc_destroy(data_ctx);
3076                 return ERROR_NT(NT_STATUS_NO_MEMORY);
3077         }
3078         pdata = *ppdata;
3079
3080         create_time_ts = get_create_timespec(&sbuf,lp_fake_dir_create_times(SNUM(conn)));
3081         mtime_ts = get_mtimespec(&sbuf);
3082         atime_ts = get_atimespec(&sbuf);
3083
3084         allocation_size = get_allocation_size(conn,fsp,&sbuf);
3085
3086         if (fsp) {
3087                 if (fsp->pending_modtime) {
3088                         /* the pending modtime overrides the current modtime */
3089                         mtime_ts.tv_sec = fsp->pending_modtime;
3090                         mtime_ts.tv_nsec = 0;
3091                 }
3092         } else {
3093                 /* Do we have this path open ? */
3094                 files_struct *fsp1 = file_find_di_first(sbuf.st_dev, sbuf.st_ino);
3095                 if (fsp1 && fsp1->pending_modtime) {
3096                         /* the pending modtime overrides the current modtime */
3097                         mtime_ts.tv_sec = fsp1->pending_modtime;
3098                         mtime_ts.tv_nsec = 0;
3099                 }
3100                 if (fsp1 && fsp1->initial_allocation_size) {
3101                         allocation_size = get_allocation_size(conn, fsp1, &sbuf);
3102                 }
3103         }
3104
3105         if (lp_dos_filetime_resolution(SNUM(conn))) {
3106                 dos_filetime_timespec(&create_time_ts);
3107                 dos_filetime_timespec(&mtime_ts);
3108                 dos_filetime_timespec(&atime_ts);
3109         }
3110
3111         create_time = convert_timespec_to_time_t(create_time_ts);
3112         mtime = convert_timespec_to_time_t(mtime_ts);
3113         atime = convert_timespec_to_time_t(atime_ts);
3114
3115         /* NT expects the name to be in an exact form of the *full*
3116            filename. See the trans2 torture test */
3117         if (strequal(base_name,".")) {
3118                 pstrcpy(dos_fname, "\\");
3119         } else {
3120                 pstr_sprintf(dos_fname, "\\%s", fname);
3121                 string_replace(dos_fname, '/', '\\');
3122         }
3123
3124         switch (info_level) {
3125                 case SMB_INFO_STANDARD:
3126                         DEBUG(10,("call_trans2qfilepathinfo: SMB_INFO_STANDARD\n"));
3127                         data_size = 22;
3128                         srv_put_dos_date2(pdata,l1_fdateCreation,create_time);
3129                         srv_put_dos_date2(pdata,l1_fdateLastAccess,atime);
3130                         srv_put_dos_date2(pdata,l1_fdateLastWrite,mtime); /* write time */
3131                         SIVAL(pdata,l1_cbFile,(uint32)file_size);
3132                         SIVAL(pdata,l1_cbFileAlloc,(uint32)allocation_size);
3133                         SSVAL(pdata,l1_attrFile,mode);
3134                         break;
3135
3136                 case SMB_INFO_QUERY_EA_SIZE:
3137                 {
3138                         unsigned int ea_size = estimate_ea_size(conn, fsp, fname);
3139                         DEBUG(10,("call_trans2qfilepathinfo: SMB_INFO_QUERY_EA_SIZE\n"));
3140                         data_size = 26;
3141                         srv_put_dos_date2(pdata,0,create_time);
3142                         srv_put_dos_date2(pdata,4,atime);
3143                         srv_put_dos_date2(pdata,8,mtime); /* write time */
3144                         SIVAL(pdata,12,(uint32)file_size);
3145                         SIVAL(pdata,16,(uint32)allocation_size);
3146                         SSVAL(pdata,20,mode);
3147                         SIVAL(pdata,22,ea_size);
3148                         break;
3149                 }
3150
3151                 case SMB_INFO_IS_NAME_VALID:
3152                         DEBUG(10,("call_trans2qfilepathinfo: SMB_INFO_IS_NAME_VALID\n"));
3153                         if (tran_call == TRANSACT2_QFILEINFO) {
3154                                 /* os/2 needs this ? really ?*/
3155                                 return ERROR_DOS(ERRDOS,ERRbadfunc);
3156                         }
3157                         data_size = 0;
3158                         param_size = 0;
3159                         break;
3160
3161                 case SMB_INFO_QUERY_EAS_FROM_LIST:
3162                 {
3163                         size_t total_ea_len = 0;
3164                         struct ea_list *ea_file_list = NULL;
3165
3166                         DEBUG(10,("call_trans2qfilepathinfo: SMB_INFO_QUERY_EAS_FROM_LIST\n"));
3167
3168                         ea_file_list = get_ea_list_from_file(data_ctx, conn, fsp, fname, &total_ea_len);
3169                         ea_list = ea_list_union(ea_list, ea_file_list, &total_ea_len);
3170
3171                         if (!ea_list || (total_ea_len > data_size)) {
3172                                 talloc_destroy(data_ctx);
3173                                 data_size = 4;
3174                                 SIVAL(pdata,0,4);   /* EA List Length must be set to 4 if no EA's. */
3175                                 break;
3176                         }
3177
3178                         data_size = fill_ea_buffer(data_ctx, pdata, data_size, conn, ea_list);
3179                         talloc_destroy(data_ctx);
3180                         break;
3181                 }
3182
3183                 case SMB_INFO_QUERY_ALL_EAS:
3184                 {
3185                         /* We have data_size bytes to put EA's into. */
3186                         size_t total_ea_len = 0;
3187
3188                         DEBUG(10,("call_trans2qfilepathinfo: SMB_INFO_QUERY_ALL_EAS\n"));
3189
3190                         data_ctx = talloc_init("ea_ctx");
3191                         if (!data_ctx) {
3192                                 return ERROR_NT(NT_STATUS_NO_MEMORY);
3193                         }
3194
3195                         ea_list = get_ea_list_from_file(data_ctx, conn, fsp, fname, &total_ea_len);
3196                         if (!ea_list || (total_ea_len > data_size)) {
3197                                 talloc_destroy(data_ctx);
3198                                 data_size = 4;
3199                                 SIVAL(pdata,0,4);   /* EA List Length must be set to 4 if no EA's. */
3200                                 break;
3201                         }
3202
3203                         data_size = fill_ea_buffer(data_ctx, pdata, data_size, conn, ea_list);
3204                         talloc_destroy(data_ctx);
3205                         break;
3206                 }
3207
3208                 case SMB_FILE_BASIC_INFORMATION:
3209                 case SMB_QUERY_FILE_BASIC_INFO:
3210
3211                         if (info_level == SMB_QUERY_FILE_BASIC_INFO) {
3212                                 DEBUG(10,("call_trans2qfilepathinfo: SMB_QUERY_FILE_BASIC_INFO\n"));
3213                                 data_size = 36; /* w95 returns 40 bytes not 36 - why ?. */
3214                         } else {
3215                                 DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_BASIC_INFORMATION\n"));
3216                                 data_size = 40;
3217                                 SIVAL(pdata,36,0);
3218                         }
3219                         put_long_date_timespec(pdata,create_time_ts);
3220                         put_long_date_timespec(pdata+8,atime_ts);
3221                         put_long_date_timespec(pdata+16,mtime_ts); /* write time */
3222                         put_long_date_timespec(pdata+24,mtime_ts); /* change time */
3223                         SIVAL(pdata,32,mode);
3224
3225                         DEBUG(5,("SMB_QFBI - "));
3226                         DEBUG(5,("create: %s ", ctime(&create_time)));
3227                         DEBUG(5,("access: %s ", ctime(&atime)));
3228                         DEBUG(5,("write: %s ", ctime(&mtime)));
3229                         DEBUG(5,("change: %s ", ctime(&mtime)));
3230                         DEBUG(5,("mode: %x\n", mode));
3231                         break;
3232
3233                 case SMB_FILE_STANDARD_INFORMATION:
3234                 case SMB_QUERY_FILE_STANDARD_INFO:
3235
3236                         DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_STANDARD_INFORMATION\n"));
3237                         data_size = 24;
3238                         SOFF_T(pdata,0,allocation_size);
3239                         SOFF_T(pdata,8,file_size);
3240                         SIVAL(pdata,16,nlink);
3241                         SCVAL(pdata,20,delete_pending?1:0);
3242                         SCVAL(pdata,21,(mode&aDIR)?1:0);
3243                         SSVAL(pdata,22,0); /* Padding. */
3244                         break;
3245
3246                 case SMB_FILE_EA_INFORMATION:
3247                 case SMB_QUERY_FILE_EA_INFO:
3248                 {
3249                         unsigned int ea_size = estimate_ea_size(conn, fsp, fname);
3250                         DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_EA_INFORMATION\n"));
3251                         data_size = 4;
3252                         SIVAL(pdata,0,ea_size);
3253                         break;
3254                 }
3255
3256                 /* Get the 8.3 name - used if NT SMB was negotiated. */
3257                 case SMB_QUERY_FILE_ALT_NAME_INFO:
3258                 case SMB_FILE_ALTERNATE_NAME_INFORMATION:
3259                 {
3260                         pstring short_name;
3261
3262                         DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_ALTERNATE_NAME_INFORMATION\n"));
3263                         pstrcpy(short_name,base_name);
3264                         /* Mangle if not already 8.3 */
3265                         if(!mangle_is_8_3(short_name, True, conn->params)) {
3266                                 mangle_map(short_name,True,True,conn->params);
3267                         }
3268                         len = srvstr_push(outbuf, pdata+4, short_name, -1, STR_UNICODE);
3269                         data_size = 4 + len;
3270                         SIVAL(pdata,0,len);
3271                         break;
3272                 }
3273
3274                 case SMB_QUERY_FILE_NAME_INFO:
3275                         /*
3276                           this must be *exactly* right for ACLs on mapped drives to work
3277                          */
3278                         len = srvstr_push(outbuf, pdata+4, dos_fname, -1, STR_UNICODE);
3279                         DEBUG(10,("call_trans2qfilepathinfo: SMB_QUERY_FILE_NAME_INFO\n"));
3280                         data_size = 4 + len;
3281                         SIVAL(pdata,0,len);
3282                         break;
3283
3284                 case SMB_FILE_ALLOCATION_INFORMATION:
3285                 case SMB_QUERY_FILE_ALLOCATION_INFO:
3286                         DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_ALLOCATION_INFORMATION\n"));
3287                         data_size = 8;
3288                         SOFF_T(pdata,0,allocation_size);
3289                         break;
3290
3291                 case SMB_FILE_END_OF_FILE_INFORMATION:
3292                 case SMB_QUERY_FILE_END_OF_FILEINFO:
3293                         DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_END_OF_FILE_INFORMATION\n"));
3294                         data_size = 8;
3295                         SOFF_T(pdata,0,file_size);
3296                         break;
3297
3298                 case SMB_QUERY_FILE_ALL_INFO:
3299                 case SMB_FILE_ALL_INFORMATION:
3300                 {
3301                         unsigned int ea_size = estimate_ea_size(conn, fsp, fname);
3302                         DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_ALL_INFORMATION\n"));
3303                         put_long_date_timespec(pdata,create_time_ts);
3304                         put_long_date_timespec(pdata+8,atime_ts);
3305                         put_long_date_timespec(pdata+16,mtime_ts); /* write time */
3306                         put_long_date_timespec(pdata+24,mtime_ts); /* change time */
3307                         SIVAL(pdata,32,mode);
3308                         SIVAL(pdata,36,0); /* padding. */
3309                         pdata += 40;
3310                         SOFF_T(pdata,0,allocation_size);
3311                         SOFF_T(pdata,8,file_size);
3312                         SIVAL(pdata,16,nlink);
3313                         SCVAL(pdata,20,delete_pending);
3314                         SCVAL(pdata,21,(mode&aDIR)?1:0);
3315                         SSVAL(pdata,22,0);
3316                         pdata += 24;
3317                         SIVAL(pdata,0,ea_size);
3318                         pdata += 4; /* EA info */
3319                         len = srvstr_push(outbuf, pdata+4, dos_fname, -1, STR_UNICODE);
3320                         SIVAL(pdata,0,len);
3321                         pdata += 4 + len;
3322                         data_size = PTR_DIFF(pdata,(*ppdata));
3323                         break;
3324                 }
3325                 case SMB_FILE_INTERNAL_INFORMATION:
3326                         /* This should be an index number - looks like
3327                            dev/ino to me :-)
3328
3329                            I think this causes us to fail the IFSKIT
3330                            BasicFileInformationTest. -tpot */
3331
3332                         DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_INTERNAL_INFORMATION\n"));
3333                         SIVAL(pdata,0,sbuf.st_ino); /* FileIndexLow */
3334                         SIVAL(pdata,4,sbuf.st_dev); /* FileIndexHigh */
3335                         data_size = 8;
3336                         break;
3337
3338                 case SMB_FILE_ACCESS_INFORMATION:
3339                         DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_ACCESS_INFORMATION\n"));
3340                         SIVAL(pdata,0,access_mask);
3341                         data_size = 4;
3342                         break;
3343
3344                 case SMB_FILE_NAME_INFORMATION:
3345                         /* Pathname with leading '\'. */
3346                         {
3347                                 size_t byte_len;
3348                                 byte_len = dos_PutUniCode(pdata+4,dos_fname,(size_t)max_data_bytes,False);
3349                                 DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_NAME_INFORMATION\n"));
3350                                 SIVAL(pdata,0,byte_len);
3351                                 data_size = 4 + byte_len;
3352                                 break;
3353                         }
3354
3355                 case SMB_FILE_DISPOSITION_INFORMATION:
3356                         DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_DISPOSITION_INFORMATION\n"));
3357                         data_size = 1;
3358                         SCVAL(pdata,0,delete_pending);
3359                         break;
3360
3361                 case SMB_FILE_POSITION_INFORMATION:
3362                         DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_POSITION_INFORMATION\n"));
3363                         data_size = 8;
3364                         SOFF_T(pdata,0,pos);
3365                         break;
3366
3367                 case SMB_FILE_MODE_INFORMATION:
3368                         DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_MODE_INFORMATION\n"));
3369                         SIVAL(pdata,0,mode);
3370                         data_size = 4;
3371                         break;
3372
3373                 case SMB_FILE_ALIGNMENT_INFORMATION:
3374                         DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_ALIGNMENT_INFORMATION\n"));
3375                         SIVAL(pdata,0,0); /* No alignment needed. */
3376                         data_size = 4;
3377                         break;
3378
3379 #if 0
3380                 /*
3381                  * NT4 server just returns "invalid query" to this - if we try to answer
3382                  * it then NTws gets a BSOD! (tridge).
3383                  * W2K seems to want this. JRA.
3384                  */
3385                 case SMB_QUERY_FILE_STREAM_INFO:
3386 #endif
3387                 case SMB_FILE_STREAM_INFORMATION:
3388                         DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_STREAM_INFORMATION\n"));
3389                         if (mode & aDIR) {
3390                                 data_size = 0;
3391                         } else {
3392                                 size_t byte_len = dos_PutUniCode(pdata+24,"::$DATA", (size_t)0xE, False);
3393                                 SIVAL(pdata,0,0); /* ??? */
3394                                 SIVAL(pdata,4,byte_len); /* Byte length of unicode string ::$DATA */
3395                                 SOFF_T(pdata,8,file_size);
3396                                 SIVAL(pdata,16,allocation_size);
3397                                 SIVAL(pdata,20,0); /* ??? */
3398                                 data_size = 24 + byte_len;
3399                         }
3400                         break;
3401
3402                 case SMB_QUERY_COMPRESSION_INFO:
3403                 case SMB_FILE_COMPRESSION_INFORMATION:
3404                         DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_COMPRESSION_INFORMATION\n"));
3405                         SOFF_T(pdata,0,file_size);
3406                         SIVAL(pdata,8,0); /* ??? */
3407                         SIVAL(pdata,12,0); /* ??? */
3408                         data_size = 16;
3409                         break;
3410
3411                 case SMB_FILE_NETWORK_OPEN_INFORMATION:
3412                         DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_NETWORK_OPEN_INFORMATION\n"));
3413                         put_long_date_timespec(pdata,create_time_ts);
3414                         put_long_date_timespec(pdata+8,atime_ts);
3415                         put_long_date_timespec(pdata+16,mtime_ts); /* write time */
3416                         put_long_date_timespec(pdata+24,mtime_ts); /* change time */
3417                         SIVAL(pdata,32,allocation_size);
3418                         SOFF_T(pdata,40,file_size);
3419                         SIVAL(pdata,48,mode);
3420                         SIVAL(pdata,52,0); /* ??? */
3421                         data_size = 56;
3422                         break;
3423
3424                 case SMB_FILE_ATTRIBUTE_TAG_INFORMATION:
3425                         DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_ATTRIBUTE_TAG_INFORMATION\n"));
3426                         SIVAL(pdata,0,mode);
3427                         SIVAL(pdata,4,0);
3428                         data_size = 8;
3429                         break;
3430
3431                 /*
3432                  * CIFS UNIX Extensions.
3433                  */
3434
3435                 case SMB_QUERY_FILE_UNIX_BASIC:
3436
3437                         DEBUG(10,("call_trans2qfilepathinfo: SMB_QUERY_FILE_UNIX_BASIC\n"));
3438                         DEBUG(4,("call_trans2qfilepathinfo: st_mode=%o\n",(int)sbuf.st_mode));
3439
3440                         SOFF_T(pdata,0,get_file_size(sbuf));             /* File size 64 Bit */
3441                         pdata += 8;
3442
3443                         SOFF_T(pdata,0,get_allocation_size(conn,fsp,&sbuf)); /* Number of bytes used on disk - 64 Bit */
3444                         pdata += 8;
3445
3446                         put_long_date_timespec(pdata,get_ctimespec(&sbuf));       /* Creation Time 64 Bit */
3447                         put_long_date_timespec(pdata+8,get_atimespec(&sbuf));     /* Last access time 64 Bit */
3448                         put_long_date_timespec(pdata+16,get_mtimespec(&sbuf));    /* Last modification time 64 Bit */
3449                         pdata += 24;
3450
3451                         SIVAL(pdata,0,sbuf.st_uid);               /* user id for the owner */
3452                         SIVAL(pdata,4,0);
3453                         pdata += 8;
3454
3455                         SIVAL(pdata,0,sbuf.st_gid);               /* group id of owner */
3456                         SIVAL(pdata,4,0);
3457                         pdata += 8;
3458
3459                         SIVAL(pdata,0,unix_filetype(sbuf.st_mode));
3460                         pdata += 4;
3461
3462                         SIVAL(pdata,0,unix_dev_major(sbuf.st_rdev));   /* Major device number if type is device */
3463                         SIVAL(pdata,4,0);
3464                         pdata += 8;
3465
3466                         SIVAL(pdata,0,unix_dev_minor(sbuf.st_rdev));   /* Minor device number if type is device */
3467                         SIVAL(pdata,4,0);
3468                         pdata += 8;
3469
3470                         SINO_T_VAL(pdata,0,(SMB_INO_T)sbuf.st_ino);   /* inode number */
3471                         pdata += 8;
3472
3473                         SIVAL(pdata,0, unix_perms_to_wire(sbuf.st_mode));     /* Standard UNIX file permissions */
3474                         SIVAL(pdata,4,0);
3475                         pdata += 8;
3476
3477                         SIVAL(pdata,0,sbuf.st_nlink);             /* number of hard links */
3478                         SIVAL(pdata,4,0);
3479                         pdata += 8;
3480                         data_size = PTR_DIFF(pdata,(*ppdata));
3481
3482                         {
3483                                 int i;
3484                                 DEBUG(4,("call_trans2qfilepathinfo: SMB_QUERY_FILE_UNIX_BASIC "));
3485
3486                                 for (i=0; i<100; i++)
3487                                         DEBUG(4,("%d=%x, ",i, (*ppdata)[i]));
3488                                 DEBUG(4,("\n"));
3489                         }
3490
3491                         break;
3492
3493                 case SMB_QUERY_FILE_UNIX_LINK:
3494                         {
3495                                 pstring buffer;
3496
3497                                 DEBUG(10,("call_trans2qfilepathinfo: SMB_QUERY_FILE_UNIX_LINK\n"));
3498 #ifdef S_ISLNK
3499                                 if(!S_ISLNK(sbuf.st_mode))
3500                                         return(UNIXERROR(ERRSRV,ERRbadlink));
3501 #else
3502                                 return(UNIXERROR(ERRDOS,ERRbadlink));
3503 #endif
3504                                 len = SMB_VFS_READLINK(conn,fullpathname, buffer, sizeof(pstring)-1);     /* read link */
3505                                 if (len == -1)
3506                                         return(UNIXERROR(ERRDOS,ERRnoaccess));
3507                                 buffer[len] = 0;
3508                                 len = srvstr_push(outbuf, pdata, buffer, -1, STR_TERMINATE);
3509                                 pdata += len;
3510                                 data_size = PTR_DIFF(pdata,(*ppdata));
3511
3512                                 break;
3513                         }
3514
3515 #if defined(HAVE_POSIX_ACLS)
3516                 case SMB_QUERY_POSIX_ACL:
3517                         {
3518                                 SMB_ACL_T file_acl = NULL;
3519                                 SMB_ACL_T def_acl = NULL;
3520                                 uint16 num_file_acls = 0;
3521                                 uint16 num_def_acls = 0;
3522
3523                                 if (fsp && !fsp->is_directory && (fsp->fh->fd != -1)) {
3524                                         file_acl = SMB_VFS_SYS_ACL_GET_FD(fsp, fsp->fh->fd);
3525                                 } else {
3526                                         file_acl = SMB_VFS_SYS_ACL_GET_FILE(conn, fname, SMB_ACL_TYPE_ACCESS);
3527                                 }
3528
3529                                 if (file_acl == NULL && no_acl_syscall_error(errno)) {
3530                                         DEBUG(5,("call_trans2qfilepathinfo: ACLs not implemented on filesystem containing %s\n",
3531                                                 fname ));
3532                                         return ERROR_NT(NT_STATUS_NOT_IMPLEMENTED);
3533                                 }
3534
3535                                 if (S_ISDIR(sbuf.st_mode)) {
3536                                         if (fsp && fsp->is_directory) {
3537                                                 def_acl = SMB_VFS_SYS_ACL_GET_FILE(conn, fsp->fsp_name, SMB_ACL_TYPE_DEFAULT);
3538                                         } else {
3539                                                 def_acl = SMB_VFS_SYS_ACL_GET_FILE(conn, fname, SMB_ACL_TYPE_DEFAULT);
3540                                         }
3541                                         def_acl = free_empty_sys_acl(conn, def_acl);
3542                                 }
3543
3544                                 num_file_acls = count_acl_entries(conn, file_acl);
3545                                 num_def_acls = count_acl_entries(conn, def_acl);
3546
3547                                 if ( data_size < (num_file_acls + num_def_acls)*SMB_POSIX_ACL_ENTRY_SIZE + SMB_POSIX_ACL_HEADER_SIZE) {
3548                                         DEBUG(5,("call_trans2qfilepathinfo: data_size too small (%u) need %u\n",
3549                                                 data_size,
3550                                                 (unsigned int)((num_file_acls + num_def_acls)*SMB_POSIX_ACL_ENTRY_SIZE +
3551                                                         SMB_POSIX_ACL_HEADER_SIZE) ));
3552                                         if (file_acl) {
3553                                                 SMB_VFS_SYS_ACL_FREE_ACL(conn, file_acl);
3554                                         }
3555                                         if (def_acl) {
3556                                                 SMB_VFS_SYS_ACL_FREE_ACL(conn, def_acl);
3557                                         }
3558                                         return ERROR_NT(NT_STATUS_BUFFER_TOO_SMALL);
3559                                 }
3560
3561                                 SSVAL(pdata,0,SMB_POSIX_ACL_VERSION);
3562                                 SSVAL(pdata,2,num_file_acls);
3563                                 SSVAL(pdata,4,num_def_acls);
3564                                 if (!marshall_posix_acl(conn, pdata + SMB_POSIX_ACL_HEADER_SIZE, &sbuf, file_acl)) {
3565                                         if (file_acl) {
3566                                                 SMB_VFS_SYS_ACL_FREE_ACL(conn, file_acl);
3567                                         }
3568                                         if (def_acl) {
3569                                                 SMB_VFS_SYS_ACL_FREE_ACL(conn, def_acl);
3570                                         }
3571                                         return ERROR_NT(NT_STATUS_INTERNAL_ERROR);
3572                                 }
3573                                 if (!marshall_posix_acl(conn, pdata + SMB_POSIX_ACL_HEADER_SIZE + (num_file_acls*SMB_POSIX_ACL_ENTRY_SIZE), &sbuf, def_acl)) {
3574                                         if (file_acl) {
3575                                                 SMB_VFS_SYS_ACL_FREE_ACL(conn, file_acl);
3576                                         }
3577                                         if (def_acl) {
3578                                                 SMB_VFS_SYS_ACL_FREE_ACL(conn, def_acl);
3579                                         }
3580                                         return ERROR_NT(NT_STATUS_INTERNAL_ERROR);
3581                                 }
3582
3583                                 if (file_acl) {
3584                                         SMB_VFS_SYS_ACL_FREE_ACL(conn, file_acl);
3585                                 }
3586                                 if (def_acl) {
3587                                         SMB_VFS_SYS_ACL_FREE_ACL(conn, def_acl);
3588                                 }
3589                                 data_size = (num_file_acls + num_def_acls)*SMB_POSIX_ACL_ENTRY_SIZE + SMB_POSIX_ACL_HEADER_SIZE;
3590                                 break;
3591                         }
3592 #endif
3593
3594
3595                 case SMB_QUERY_POSIX_LOCK:
3596                 {
3597                         NTSTATUS status = NT_STATUS_INVALID_LEVEL;
3598                         SMB_BIG_UINT count;
3599                         SMB_BIG_UINT offset;
3600                         uint32 lock_pid;
3601                         enum brl_type lock_type;
3602
3603                         if (total_data != POSIX_LOCK_DATA_SIZE) {
3604                                 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
3605                         }
3606
3607                         switch (SVAL(pdata, POSIX_LOCK_TYPE_OFFSET)) {
3608                                 case POSIX_LOCK_TYPE_READ:
3609                                         lock_type = READ_LOCK;
3610                                         break;
3611                                 case POSIX_LOCK_TYPE_WRITE:
3612                                         lock_type = WRITE_LOCK;
3613                                         break;
3614                                 case POSIX_LOCK_TYPE_UNLOCK:
3615                                 default:
3616                                         /* There's no point in asking for an unlock... */
3617                                         talloc_destroy(data_ctx);
3618                                         return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
3619                         }
3620
3621                         lock_pid = IVAL(pdata, POSIX_LOCK_PID_OFFSET);
3622 #if defined(HAVE_LONGLONG)
3623                         offset = (((SMB_BIG_UINT) IVAL(pdata,(POSIX_LOCK_START_OFFSET+4))) << 32) |
3624                                         ((SMB_BIG_UINT) IVAL(pdata,POSIX_LOCK_START_OFFSET));
3625                         count = (((SMB_BIG_UINT) IVAL(pdata,(POSIX_LOCK_LEN_OFFSET+4))) << 32) |
3626                                         ((SMB_BIG_UINT) IVAL(pdata,POSIX_LOCK_LEN_OFFSET));
3627 #else /* HAVE_LONGLONG */
3628                         offset = (SMB_BIG_UINT)IVAL(pdata,POSIX_LOCK_START_OFFSET);
3629                         count = (SMB_BIG_UINT)IVAL(pdata,POSIX_LOCK_LEN_OFFSET);
3630 #endif /* HAVE_LONGLONG */
3631
3632                         status = query_lock(fsp,
3633                                         &lock_pid,
3634                                         &count,
3635                                         &offset,
3636                                         &lock_type,
3637                                         POSIX_LOCK);
3638
3639                         if (ERROR_WAS_LOCK_DENIED(status)) {
3640                                 /* Here we need to report who has it locked... */
3641                                 data_size = POSIX_LOCK_DATA_SIZE;
3642
3643                                 SSVAL(pdata, POSIX_LOCK_TYPE_OFFSET, lock_type);
3644                                 SSVAL(pdata, POSIX_LOCK_FLAGS_OFFSET, 0);
3645                                 SIVAL(pdata, POSIX_LOCK_PID_OFFSET, lock_pid);
3646 #if defined(HAVE_LONGLONG)
3647                                 SIVAL(pdata, POSIX_LOCK_START_OFFSET, (uint32)(offset & 0xFFFFFFFF));
3648                                 SIVAL(pdata, POSIX_LOCK_START_OFFSET + 4, (uint32)((offset >> 32) & 0xFFFFFFFF));
3649                                 SIVAL(pdata, POSIX_LOCK_LEN_OFFSET, (uint32)(count & 0xFFFFFFFF));
3650                                 SIVAL(pdata, POSIX_LOCK_LEN_OFFSET + 4, (uint32)((count >> 32) & 0xFFFFFFFF));
3651 #else /* HAVE_LONGLONG */
3652                                 SIVAL(pdata, POSIX_LOCK_START_OFFSET, offset);
3653                                 SIVAL(pdata, POSIX_LOCK_LEN_OFFSET, count);
3654 #endif /* HAVE_LONGLONG */
3655
3656                         } else if (NT_STATUS_IS_OK(status)) {
3657                                 /* For success we just return a copy of what we sent
3658                                    with the lock type set to POSIX_LOCK_TYPE_UNLOCK. */
3659                                 data_size = POSIX_LOCK_DATA_SIZE;
3660                                 memcpy(pdata, lock_data, POSIX_LOCK_DATA_SIZE);
3661                                 SSVAL(pdata, POSIX_LOCK_TYPE_OFFSET, POSIX_LOCK_TYPE_UNLOCK);
3662                         } else {
3663                                 return ERROR_NT(status);
3664                         }
3665                         break;
3666                 }
3667
3668                 default:
3669                         return ERROR_NT(NT_STATUS_INVALID_LEVEL);
3670         }
3671
3672         send_trans2_replies(outbuf, bufsize, params, param_size, *ppdata, data_size, max_data_bytes);
3673
3674         return(-1);
3675 }
3676
3677 /****************************************************************************
3678  Set a hard link (called by UNIX extensions and by NT rename with HARD link
3679  code.
3680 ****************************************************************************/
3681
3682 NTSTATUS hardlink_internals(connection_struct *conn, pstring oldname, pstring newname)
3683 {
3684         SMB_STRUCT_STAT sbuf1, sbuf2;
3685         pstring last_component_oldname;
3686         pstring last_component_newname;
3687         NTSTATUS status = NT_STATUS_OK;
3688
3689         ZERO_STRUCT(sbuf1);
3690         ZERO_STRUCT(sbuf2);
3691
3692         status = unix_convert(conn, oldname, False, last_component_oldname, &sbuf1);
3693         if (!NT_STATUS_IS_OK(status)) {
3694                 return status;
3695         }
3696
3697         /* source must already exist. */
3698         if (!VALID_STAT(sbuf1)) {
3699                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
3700         }
3701
3702         status = check_name(conn, oldname);
3703         if (!NT_STATUS_IS_OK(status)) {
3704                 return NT_STATUS_ACCESS_DENIED;
3705         }
3706
3707         status = unix_convert(conn, newname, False, last_component_newname, &sbuf2);
3708         if (!NT_STATUS_IS_OK(status)) {
3709                 return status;
3710         }
3711
3712         /* Disallow if newname already exists. */
3713         if (VALID_STAT(sbuf2)) {
3714                 return NT_STATUS_OBJECT_NAME_COLLISION;
3715         }
3716
3717         status = check_name(conn, newname);
3718         if (!NT_STATUS_IS_OK(status)) {
3719                 return NT_STATUS_ACCESS_DENIED;
3720         }
3721
3722         /* No links from a directory. */
3723         if (S_ISDIR(sbuf1.st_mode)) {
3724                 return NT_STATUS_FILE_IS_A_DIRECTORY;
3725         }
3726
3727         /* Ensure this is within the share. */
3728         status = reduce_name(conn, oldname);
3729         if (!NT_STATUS_IS_OK(status)) {
3730                 return status;
3731         }
3732
3733         DEBUG(10,("hardlink_internals: doing hard link %s -> %s\n", newname, oldname ));
3734
3735         if (SMB_VFS_LINK(conn,oldname,newname) != 0) {
3736                 status = map_nt_error_from_unix(errno);
3737                 DEBUG(3,("hardlink_internals: Error %s hard link %s -> %s\n",
3738                                 nt_errstr(status), newname, oldname));
3739         }
3740
3741         return status;
3742 }
3743
3744 /****************************************************************************
3745  Deal with SMB_INFO_SET_EA.
3746 ****************************************************************************/
3747
3748 static int smb_info_set_ea(connection_struct *conn,
3749                                 char *outbuf,
3750                                 int bufsize,
3751                                 char *params,
3752                                 const char *pdata,
3753                                 int total_data,
3754                                 unsigned int max_data_bytes,
3755                                 files_struct *fsp,
3756                                 const char *fname)
3757 {
3758         struct ea_list *ea_list = NULL;
3759         TALLOC_CTX *ctx = NULL;
3760         NTSTATUS status = NT_STATUS_OK;
3761
3762         if (total_data < 10) {
3763
3764                 /* OS/2 workplace shell seems to send SET_EA requests of "null"
3765                    length. They seem to have no effect. Bug #3212. JRA */
3766
3767                 if ((total_data == 4) && (IVAL(pdata,0) == 4)) {
3768                         /* We're done. We only get EA info in this call. */
3769                         SSVAL(params,0,0);
3770                         send_trans2_replies(outbuf, bufsize, params, 2, pdata, 0, max_data_bytes);
3771                         return -1;
3772                 }
3773
3774                 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
3775         }
3776
3777         if (IVAL(pdata,0) > total_data) {
3778                 DEBUG(10,("smb_info_set_ea: bad total data size (%u) > %u\n",
3779                         IVAL(pdata,0), (unsigned int)total_data));
3780                 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
3781         }
3782
3783         ctx = talloc_init("SMB_INFO_SET_EA");
3784         if (!ctx) {
3785                 return ERROR_NT(NT_STATUS_NO_MEMORY);
3786         }
3787         ea_list = read_ea_list(ctx, pdata + 4, total_data - 4);
3788         if (!ea_list) {
3789                 talloc_destroy(ctx);
3790                 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
3791         }
3792         status = set_ea(conn, fsp, fname, ea_list);
3793         talloc_destroy(ctx);
3794
3795         if (!NT_STATUS_IS_OK(status)) {
3796                 return ERROR_NT(status);
3797         }
3798
3799         /* We're done. We only get EA info in this call. */
3800         SSVAL(params,0,0);
3801         send_trans2_replies(outbuf, bufsize, params, 2, pdata, 0, max_data_bytes);
3802         return -1;
3803 }
3804
3805 /****************************************************************************
3806  Deal with SMB_SET_FILE_DISPOSITION_INFO.
3807 ****************************************************************************/
3808
3809 static int smb_set_file_disposition_info(connection_struct *conn,
3810                                 char *outbuf,
3811                                 int bufsize,
3812                                 char *params,
3813                                 const char *pdata,
3814                                 int total_data,
3815                                 unsigned int max_data_bytes,
3816                                 files_struct *fsp,
3817                                 int dosmode)
3818 {
3819         NTSTATUS status = NT_STATUS_OK;
3820         BOOL delete_on_close;
3821
3822         if (total_data < 1) {
3823                 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
3824         }
3825
3826         if (fsp == NULL) {
3827                 return(UNIXERROR(ERRDOS,ERRbadfid));
3828         }
3829
3830         delete_on_close = (CVAL(pdata,0) ? True : False);
3831
3832         status = can_set_delete_on_close(fsp, delete_on_close, dosmode);
3833
3834         if (!NT_STATUS_IS_OK(status)) {
3835                 return ERROR_NT(status);
3836         }
3837
3838         /* The set is across all open files on this dev/inode pair. */
3839         if (!set_delete_on_close(fsp, delete_on_close, &current_user.ut)) {
3840                 return ERROR_NT(NT_STATUS_ACCESS_DENIED);
3841         }
3842
3843         SSVAL(params,0,0);
3844         send_trans2_replies(outbuf, bufsize, params, 2, pdata, 0, max_data_bytes);
3845         return -1;
3846 }
3847
3848 /****************************************************************************
3849  Deal with SMB_FILE_POSITION_INFORMATION.
3850 ****************************************************************************/
3851
3852 static int smb_file_position_information(connection_struct *conn,
3853                                 char *outbuf,
3854                                 int bufsize,
3855                                 char *params,
3856                                 const char *pdata,
3857                                 int total_data,
3858                                 unsigned int max_data_bytes,
3859                                 files_struct *fsp)
3860 {
3861         SMB_BIG_UINT position_information;
3862
3863         if (total_data < 8) {
3864                 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
3865         }
3866
3867         if (!fsp) {
3868                 /* Ignore on pathname based set. */
3869                 SSVAL(params,0,0);
3870                 send_trans2_replies(outbuf, bufsize, params, 2, pdata, 0, max_data_bytes);
3871                 return -1;
3872         }
3873
3874         position_information = (SMB_BIG_UINT)IVAL(pdata,0);
3875 #ifdef LARGE_SMB_OFF_T
3876         position_information |= (((SMB_BIG_UINT)IVAL(pdata,4)) << 32);
3877 #else /* LARGE_SMB_OFF_T */
3878         if (IVAL(pdata,4) != 0) {
3879                 /* more than 32 bits? */
3880                 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
3881         }
3882 #endif /* LARGE_SMB_OFF_T */
3883
3884         DEBUG(10,("smb_file_position_information: Set file position information for file %s to %.0f\n",
3885                 fsp->fsp_name, (double)position_information ));
3886         fsp->fh->position_information = position_information;
3887
3888         /* We're done. We only set position info in this call. */
3889         SSVAL(params,0,0);
3890         send_trans2_replies(outbuf, bufsize, params, 2, pdata, 0, max_data_bytes);
3891         return -1;
3892 }
3893
3894 /****************************************************************************
3895  Deal with SMB_FILE_MODE_INFORMATION.
3896 ****************************************************************************/
3897
3898 static int smb_file_mode_information(connection_struct *conn,
3899                                 char *outbuf,
3900                                 int bufsize,
3901                                 char *params,
3902                                 const char *pdata,
3903                                 int total_data,
3904                                 unsigned int max_data_bytes)
3905 {
3906         uint32 mode;
3907
3908         if (total_data < 4) {
3909                 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
3910         }
3911         mode = IVAL(pdata,0);
3912         if (mode != 0 && mode != 2 && mode != 4 && mode != 6) {
3913                 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
3914         }
3915
3916         /* We're done. We only set (?) mode info in this call. */
3917         SSVAL(params,0,0);
3918         send_trans2_replies(outbuf, bufsize, params, 2, pdata, 0, max_data_bytes);
3919         return -1;
3920 }
3921
3922 /****************************************************************************
3923  Deal with SMB_SET_FILE_UNIX_LINK (create a UNIX symlink).
3924 ****************************************************************************/
3925
3926 static int smb_set_file_unix_link(connection_struct *conn,
3927                                 char *inbuf,
3928                                 char *outbuf,
3929                                 int bufsize,
3930                                 char *params,
3931                                 const char *pdata,
3932                                 int total_data,
3933                                 unsigned int max_data_bytes,
3934                                 const char *fname)
3935 {
3936         pstring link_target;
3937         const char *newname = fname;
3938         NTSTATUS status = NT_STATUS_OK;
3939
3940         /* Set a symbolic link. */
3941         /* Don't allow this if follow links is false. */
3942
3943         if (total_data == 0) {
3944                 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
3945         }
3946
3947         if (!lp_symlinks(SNUM(conn))) {
3948                 return(ERROR_DOS(ERRDOS,ERRnoaccess));
3949         }
3950
3951         srvstr_pull(inbuf, link_target, pdata, sizeof(link_target), total_data, STR_TERMINATE);
3952
3953         /* !widelinks forces the target path to be within the share. */
3954         /* This means we can interpret the target as a pathname. */
3955         if (!lp_widelinks(SNUM(conn))) {
3956                 pstring rel_name;
3957                 char *last_dirp = NULL;
3958
3959                 unix_format(link_target);
3960                 if (*link_target == '/') {
3961                         /* No absolute paths allowed. */
3962                         return(UNIXERROR(ERRDOS,ERRnoaccess));
3963                 }
3964                 pstrcpy(rel_name, newname);
3965                 last_dirp = strrchr_m(rel_name, '/');
3966                 if (last_dirp) {
3967                         last_dirp[1] = '\0';
3968                 } else {
3969                         pstrcpy(rel_name, "./");
3970                 }
3971                 pstrcat(rel_name, link_target);
3972
3973                 status = check_name(conn, rel_name);
3974                 if (!NT_STATUS_IS_OK(status)) {
3975                         return ERROR_NT(status);
3976                 }
3977         }
3978
3979         DEBUG(10,("smb_set_file_unix_link: SMB_SET_FILE_UNIX_LINK doing symlink %s -> %s\n",
3980                         newname, link_target ));
3981
3982         if (SMB_VFS_SYMLINK(conn,link_target,newname) != 0) {
3983                 return(UNIXERROR(ERRDOS,ERRnoaccess));
3984         }
3985
3986         SSVAL(params,0,0);
3987         send_trans2_replies(outbuf, bufsize, params, 2, pdata, 0, max_data_bytes);
3988         return -1;
3989 }
3990
3991 /****************************************************************************
3992  Deal with SMB_SET_FILE_UNIX_HLINK (create a UNIX hard link).
3993 ****************************************************************************/
3994
3995 static int smb_set_file_unix_hlink(connection_struct *conn,
3996                                 char *inbuf,
3997                                 char *outbuf,
3998                                 int bufsize,
3999                                 char *params,
4000                                 const char *pdata,
4001                                 int total_data,
4002                                 unsigned int max_data_bytes,
4003                                 pstring fname)
4004 {
4005         pstring oldname;
4006         NTSTATUS status = NT_STATUS_OK;
4007
4008         /* Set a hard link. */
4009         if (total_data == 0) {
4010                 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
4011         }
4012
4013         srvstr_get_path(inbuf, oldname, pdata, sizeof(oldname), total_data, STR_TERMINATE, &status);
4014         if (!NT_STATUS_IS_OK(status)) {
4015                 return ERROR_NT(status);
4016         }
4017
4018         DEBUG(10,("smb_set_file_unix_hlink: SMB_SET_FILE_UNIX_LINK doing hard link %s -> %s\n",
4019                 fname, oldname));
4020
4021         status = hardlink_internals(conn, oldname, fname);
4022         if (!NT_STATUS_IS_OK(status)) {
4023                 return ERROR_NT(status);
4024         }
4025
4026         SSVAL(params,0,0);
4027         send_trans2_replies(outbuf, bufsize, params, 2, pdata, 0, max_data_bytes);
4028         return -1;
4029 }
4030
4031 /****************************************************************************
4032  Deal with SMB_FILE_RENAME_INFORMATION.
4033 ****************************************************************************/
4034
4035 static int smb_file_rename_information(connection_struct *conn,
4036                                 char *inbuf,
4037                                 char *outbuf,
4038                                 int bufsize,
4039                                 char *params,
4040                                 const char *pdata,
4041                                 int total_data,
4042                                 unsigned int max_data_bytes,
4043                                 files_struct *fsp,
4044                                 pstring fname)
4045 {
4046         BOOL overwrite;
4047         /* uint32 root_fid; */  /* Not used */
4048         uint32 len;
4049         pstring newname;
4050         pstring base_name;
4051         NTSTATUS status = NT_STATUS_OK;
4052         char *p;
4053
4054         if (total_data < 13) {
4055                 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
4056         }
4057
4058         overwrite = (CVAL(pdata,0) ? True : False);
4059         /* root_fid = IVAL(pdata,4); */
4060         len = IVAL(pdata,8);
4061
4062         if (len > (total_data - 12) || (len == 0)) {
4063                 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
4064         }
4065
4066         srvstr_get_path(inbuf, newname, &pdata[12], sizeof(newname), len, 0, &status);
4067         if (!NT_STATUS_IS_OK(status)) {
4068                 return ERROR_NT(status);
4069         }
4070
4071         /* Check the new name has no '/' characters. */
4072         if (strchr_m(newname, '/')) {
4073                 return ERROR_NT(NT_STATUS_NOT_SUPPORTED);
4074         }
4075
4076         RESOLVE_DFSPATH(newname, conn, inbuf, outbuf);
4077
4078         /* Create the base directory. */
4079         pstrcpy(base_name, fname);
4080         p = strrchr_m(base_name, '/');
4081         if (p) {
4082                 *p = '\0';
4083         }
4084         /* Append the new name. */
4085         pstrcat(base_name, "/");
4086         pstrcat(base_name, newname);
4087
4088         if (fsp) {
4089                 DEBUG(10,("smb_file_rename_information: SMB_FILE_RENAME_INFORMATION (fnum %d) %s -> %s\n",
4090                         fsp->fnum, fsp->fsp_name, base_name ));
4091                 status = rename_internals_fsp(conn, fsp, base_name, 0, overwrite);
4092         } else {
4093                 DEBUG(10,("smb_file_rename_information: SMB_FILE_RENAME_INFORMATION %s -> %s\n",
4094                         fname, newname ));
4095                 status = rename_internals(conn, fname, base_name, 0, overwrite, False);
4096         }
4097
4098         if (!NT_STATUS_IS_OK(status)) {
4099                 if (open_was_deferred(SVAL(inbuf,smb_mid))) {
4100                         /* We have re-scheduled this call. */
4101                         return -1;
4102                 }
4103                 return ERROR_NT(status);
4104         }
4105
4106         SSVAL(params,0,0);
4107         send_trans2_replies(outbuf, bufsize, params, 2, pdata, 0, max_data_bytes);
4108         return -1;
4109 }
4110
4111 /****************************************************************************
4112  Deal with SMB_SET_POSIX_ACL.
4113 ****************************************************************************/
4114
4115 #if defined(HAVE_POSIX_ACLS)
4116 static int smb_set_posix_acl(connection_struct *conn,
4117                                 char *outbuf,
4118                                 int bufsize,
4119                                 char *params,
4120                                 const char *pdata,
4121                                 int total_data,
4122                                 unsigned int max_data_bytes,
4123                                 files_struct *fsp,
4124                                 const char *fname)
4125 {
4126         uint16 posix_acl_version;
4127         uint16 num_file_acls;
4128         uint16 num_def_acls;
4129         BOOL valid_file_acls = True;
4130         BOOL valid_def_acls = True;
4131
4132         if (total_data < SMB_POSIX_ACL_HEADER_SIZE) {
4133                 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
4134         }
4135         posix_acl_version = SVAL(pdata,0);
4136         num_file_acls = SVAL(pdata,2);
4137         num_def_acls = SVAL(pdata,4);
4138
4139         if (num_file_acls == SMB_POSIX_IGNORE_ACE_ENTRIES) {
4140                 valid_file_acls = False;
4141                 num_file_acls = 0;
4142         }
4143
4144         if (num_def_acls == SMB_POSIX_IGNORE_ACE_ENTRIES) {
4145                 valid_def_acls = False;
4146                 num_def_acls = 0;
4147         }
4148
4149         if (posix_acl_version != SMB_POSIX_ACL_VERSION) {
4150                 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
4151         }
4152
4153         if (total_data < SMB_POSIX_ACL_HEADER_SIZE +
4154                         (num_file_acls+num_def_acls)*SMB_POSIX_ACL_ENTRY_SIZE) {
4155                 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
4156         }
4157
4158         if (valid_file_acls && !set_unix_posix_acl(conn, fsp, fname, num_file_acls,
4159                         pdata + SMB_POSIX_ACL_HEADER_SIZE)) {
4160                 return(UNIXERROR(ERRDOS,ERRnoaccess));
4161         }
4162
4163         if (valid_def_acls && !set_unix_posix_default_acl(conn, fname, &sbuf, num_def_acls,
4164                         pdata + SMB_POSIX_ACL_HEADER_SIZE +
4165                         (num_file_acls*SMB_POSIX_ACL_ENTRY_SIZE))) {
4166                 return(UNIXERROR(ERRDOS,ERRnoaccess));
4167         }
4168
4169         SSVAL(params,0,0);
4170         send_trans2_replies(outbuf, bufsize, params, 2, pdata, 0, max_data_bytes);
4171         return -1;
4172 }
4173 #endif
4174
4175 /****************************************************************************
4176  Deal with SMB_SET_POSIX_LOCK.
4177 ****************************************************************************/
4178
4179 static int smb_set_posix_lock(connection_struct *conn,
4180                                 char *inbuf,
4181                                 char *outbuf,
4182                                 int length,
4183                                 int bufsize,
4184                                 char *params,
4185                                 const char *pdata,
4186                                 int total_data,
4187                                 unsigned int max_data_bytes,
4188                                 files_struct *fsp)
4189 {
4190         SMB_BIG_UINT count;
4191         SMB_BIG_UINT offset;
4192         uint32 lock_pid;
4193         BOOL blocking_lock = False;
4194         enum brl_type lock_type;
4195         NTSTATUS status = NT_STATUS_OK;
4196
4197         if (fsp == NULL || fsp->fh->fd == -1) {
4198                 return ERROR_NT(NT_STATUS_INVALID_HANDLE);
4199         }
4200
4201         if (total_data != POSIX_LOCK_DATA_SIZE) {
4202                 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
4203         }
4204
4205         switch (SVAL(pdata, POSIX_LOCK_TYPE_OFFSET)) {
4206                 case POSIX_LOCK_TYPE_READ:
4207                         lock_type = READ_LOCK;
4208                         break;
4209                 case POSIX_LOCK_TYPE_WRITE:
4210                         /* Return the right POSIX-mappable error code for files opened read-only. */
4211                         if (!fsp->can_write) {
4212                                 return ERROR_NT(NT_STATUS_INVALID_HANDLE);
4213                         }
4214                         lock_type = WRITE_LOCK;
4215                         break;
4216                 case POSIX_LOCK_TYPE_UNLOCK:
4217                         lock_type = UNLOCK_LOCK;
4218                         break;
4219                 default:
4220                         return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
4221         }
4222
4223         if (SVAL(pdata,POSIX_LOCK_FLAGS_OFFSET) == POSIX_LOCK_FLAG_NOWAIT) {
4224                 blocking_lock = False;
4225         } else if (SVAL(pdata,POSIX_LOCK_FLAGS_OFFSET) == POSIX_LOCK_FLAG_WAIT) {
4226                 blocking_lock = True;
4227         } else {
4228                 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
4229         }
4230
4231         if (!lp_blocking_locks(SNUM(conn))) {
4232                 blocking_lock = False;
4233         }
4234
4235         lock_pid = IVAL(pdata, POSIX_LOCK_PID_OFFSET);
4236 #if defined(HAVE_LONGLONG)
4237         offset = (((SMB_BIG_UINT) IVAL(pdata,(POSIX_LOCK_START_OFFSET+4))) << 32) |
4238                         ((SMB_BIG_UINT) IVAL(pdata,POSIX_LOCK_START_OFFSET));
4239         count = (((SMB_BIG_UINT) IVAL(pdata,(POSIX_LOCK_LEN_OFFSET+4))) << 32) |
4240                         ((SMB_BIG_UINT) IVAL(pdata,POSIX_LOCK_LEN_OFFSET));
4241 #else /* HAVE_LONGLONG */
4242         offset = (SMB_BIG_UINT)IVAL(pdata,POSIX_LOCK_START_OFFSET);
4243         count = (SMB_BIG_UINT)IVAL(pdata,POSIX_LOCK_LEN_OFFSET);
4244 #endif /* HAVE_LONGLONG */
4245
4246         if (lock_type == UNLOCK_LOCK) {
4247                 status = do_unlock(fsp,
4248                                 lock_pid,
4249                                 count,
4250                                 offset,
4251                                 POSIX_LOCK);
4252         } else {
4253                 struct byte_range_lock *br_lck = do_lock(fsp,
4254                                                         lock_pid,
4255                                                         count,
4256                                                         offset,
4257                                                         lock_type,
4258                                                         POSIX_LOCK,
4259                                                         blocking_lock,
4260                                                         &status);
4261
4262                 if (br_lck && blocking_lock && ERROR_WAS_LOCK_DENIED(status)) {
4263                         /*
4264                          * A blocking lock was requested. Package up
4265                          * this smb into a queued request and push it
4266                          * onto the blocking lock queue.
4267                          */
4268                         if(push_blocking_lock_request(br_lck,
4269                                                 inbuf, length,
4270                                                 fsp,
4271                                                 -1, /* infinite timeout. */
4272                                                 0,
4273                                                 lock_pid,
4274                                                 lock_type,
4275                                                 POSIX_LOCK,
4276                                                 offset,
4277                                                 count)) {
4278                                 TALLOC_FREE(br_lck);
4279                                 return -1;
4280                         }
4281                 }
4282                 TALLOC_FREE(br_lck);
4283         }
4284
4285         if (!NT_STATUS_IS_OK(status)) {
4286                 return ERROR_NT(status);
4287         }
4288
4289         SSVAL(params,0,0);
4290         send_trans2_replies(outbuf, bufsize, params, 2, pdata, 0, max_data_bytes);
4291         return -1;
4292 }
4293
4294 /****************************************************************************
4295  Reply to a TRANS2_SETFILEINFO (set file info by fileid or pathname).
4296 ****************************************************************************/
4297
4298 static int call_trans2setfilepathinfo(connection_struct *conn, char *inbuf, char *outbuf, int length, int bufsize,
4299                                         unsigned int tran_call,
4300                                         char **pparams, int total_params, char **ppdata, int total_data,
4301                                         unsigned int max_data_bytes)
4302 {
4303         char *params = *pparams;
4304         char *pdata = *ppdata;
4305         uint16 info_level;
4306         int dosmode=0;
4307         SMB_OFF_T size=0;
4308         struct utimbuf tvs;
4309         SMB_STRUCT_STAT sbuf;
4310         pstring fname;
4311         int fd = -1;
4312         files_struct *fsp = NULL;
4313         uid_t set_owner = (uid_t)SMB_UID_NO_CHANGE;
4314         gid_t set_grp = (uid_t)SMB_GID_NO_CHANGE;
4315         mode_t unixmode = 0;
4316         NTSTATUS status = NT_STATUS_OK;
4317
4318         if (!params)
4319                 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
4320
4321         ZERO_STRUCT(sbuf);
4322         ZERO_STRUCT(tvs);
4323
4324         if (tran_call == TRANSACT2_SETFILEINFO) {
4325                 if (total_params < 4) {
4326                         return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
4327                 }
4328
4329                 fsp = file_fsp(params,0);
4330                 info_level = SVAL(params,2);
4331
4332                 if(fsp && (fsp->is_directory || fsp->fh->fd == -1)) {
4333                         /*
4334                          * This is actually a SETFILEINFO on a directory
4335                          * handle (returned from an NT SMB). NT5.0 seems
4336                          * to do this call. JRA.
4337                          */
4338                         pstrcpy(fname, fsp->fsp_name);
4339                         if (SMB_VFS_STAT(conn,fname,&sbuf) != 0) {
4340                                 DEBUG(3,("call_trans2setfilepathinfo: fileinfo of %s failed (%s)\n",fname,strerror(errno)));
4341                                 return UNIXERROR(ERRDOS,ERRbadpath);
4342                         }
4343                 } else if (fsp && fsp->print_file) {
4344                         /*
4345                          * Doing a DELETE_ON_CLOSE should cancel a print job.
4346                          */
4347                         if ((info_level == SMB_SET_FILE_DISPOSITION_INFO) && CVAL(pdata,0)) {
4348                                 fsp->fh->private_options |= FILE_DELETE_ON_CLOSE;
4349
4350                                 DEBUG(3,("call_trans2setfilepathinfo: Cancelling print job (%s)\n", fsp->fsp_name ));
4351
4352                                 SSVAL(params,0,0);
4353                                 send_trans2_replies(outbuf, bufsize, params, 2, *ppdata, 0, max_data_bytes);
4354                                 return(-1);
4355                         } else
4356                                 return (UNIXERROR(ERRDOS,ERRbadpath));
4357             } else {
4358                         /*
4359                          * Original code - this is an open file.
4360                          */
4361                         CHECK_FSP(fsp,conn);
4362
4363                         pstrcpy(fname, fsp->fsp_name);
4364                         fd = fsp->fh->fd;
4365
4366                         if (SMB_VFS_FSTAT(fsp,fd,&sbuf) != 0) {
4367                                 DEBUG(3,("call_trans2setfilepathinfo: fstat of fnum %d failed (%s)\n",fsp->fnum, strerror(errno)));
4368                                 return(UNIXERROR(ERRDOS,ERRbadfid));
4369                         }
4370                 }
4371         } else {
4372                 /* set path info */
4373                 if (total_params < 7) {
4374                         return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
4375                 }
4376
4377                 info_level = SVAL(params,0);
4378                 srvstr_get_path(inbuf, fname, &params[6], sizeof(fname), total_params - 6, STR_TERMINATE, &status);
4379                 if (!NT_STATUS_IS_OK(status)) {
4380                         return ERROR_NT(status);
4381                 }
4382                 status = unix_convert(conn, fname, False, NULL, &sbuf);
4383                 if (!NT_STATUS_IS_OK(status)) {
4384                         return ERROR_NT(status);
4385                 }
4386
4387                 /*
4388                  * For CIFS UNIX extensions the target name may not exist.
4389                  */
4390
4391                 if(!VALID_STAT(sbuf) && !INFO_LEVEL_IS_UNIX(info_level)) {
4392                         DEBUG(3,("call_trans2setfilepathinfo: stat of %s failed (%s)\n", fname, strerror(errno)));
4393                         return UNIXERROR(ERRDOS,ERRbadpath);
4394                 }
4395
4396                 status = check_name(conn, fname);
4397                 if (!NT_STATUS_IS_OK(status)) {
4398                         return ERROR_NT(status);
4399                 }
4400
4401         }
4402
4403         if (!CAN_WRITE(conn))
4404                 return ERROR_DOS(ERRSRV,ERRaccess);
4405
4406         if (INFO_LEVEL_IS_UNIX(info_level) && !lp_unix_extensions()) {
4407                 return ERROR_NT(NT_STATUS_INVALID_LEVEL);
4408         }
4409
4410         if (VALID_STAT(sbuf))
4411                 unixmode = sbuf.st_mode;
4412
4413         DEBUG(3,("call_trans2setfilepathinfo(%d) %s (fnum %d) info_level=%d totdata=%d\n",
4414                 tran_call,fname, fsp ? fsp->fnum : -1, info_level,total_data));
4415
4416         /* Realloc the parameter size */
4417         *pparams = (char *)SMB_REALLOC(*pparams,2);
4418         if (*pparams == NULL) {
4419                 return ERROR_NT(NT_STATUS_NO_MEMORY);
4420         }
4421         params = *pparams;
4422
4423         SSVAL(params,0,0);
4424
4425         if (fsp && fsp->pending_modtime) {
4426                 /* the pending modtime overrides the current modtime */
4427                 sbuf.st_mtime = fsp->pending_modtime;
4428         }
4429
4430         size = get_file_size(sbuf);
4431         tvs.modtime = sbuf.st_mtime;
4432         tvs.actime = sbuf.st_atime;
4433         dosmode = dos_mode(conn,fname,&sbuf);
4434         unixmode = sbuf.st_mode;
4435
4436         set_owner = VALID_STAT(sbuf) ? sbuf.st_uid : (uid_t)SMB_UID_NO_CHANGE;
4437         set_grp = VALID_STAT(sbuf) ? sbuf.st_gid : (gid_t)SMB_GID_NO_CHANGE;
4438
4439         switch (info_level) {
4440                 case SMB_INFO_STANDARD:
4441                 {
4442                         if (total_data < 12) {
4443                                 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
4444                         }
4445
4446                         /* access time */
4447                         tvs.actime = srv_make_unix_date2(pdata+l1_fdateLastAccess);
4448                         /* write time */
4449                         tvs.modtime = srv_make_unix_date2(pdata+l1_fdateLastWrite);
4450                         break;
4451                 }
4452
4453                 case SMB_INFO_SET_EA:
4454                         return smb_info_set_ea(conn,
4455                                                 outbuf,
4456                                                 bufsize,
4457                                                 params,
4458                                                 *ppdata,
4459                                                 total_data,
4460                                                 max_data_bytes,
4461                                                 fsp,
4462                                                 fname);
4463
4464                 case SMB_SET_FILE_BASIC_INFO:
4465                 case SMB_FILE_BASIC_INFORMATION:
4466                 {
4467                         /* Patch to do this correctly from Paul Eggert <eggert@twinsun.com>. */
4468                         time_t write_time;
4469                         time_t changed_time;
4470
4471                         if (total_data < 36) {
4472                                 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
4473                         }
4474
4475                         /* Ignore create time at offset pdata. */
4476
4477                         /* access time */
4478                         tvs.actime = convert_timespec_to_time_t(interpret_long_date(pdata+8));
4479
4480                         write_time = convert_timespec_to_time_t(interpret_long_date(pdata+16));
4481                         changed_time = convert_timespec_to_time_t(interpret_long_date(pdata+24));
4482
4483                         tvs.modtime = MIN(write_time, changed_time);
4484
4485                         if (write_time > tvs.modtime && write_time != (time_t)-1) {
4486                                 tvs.modtime = write_time;
4487                         }
4488                         /* Prefer a defined time to an undefined one. */
4489                         if (null_mtime(tvs.modtime)) {
4490                                 tvs.modtime = null_mtime(write_time) ? changed_time : write_time;
4491                         }
4492
4493                         /* attributes */
4494                         dosmode = IVAL(pdata,32);
4495                         break;
4496                 }
4497
4498                 case SMB_FILE_ALLOCATION_INFORMATION:
4499                 case SMB_SET_FILE_ALLOCATION_INFO:
4500                 {
4501                         int ret = -1;
4502                         SMB_BIG_UINT allocation_size;
4503
4504                         if (total_data < 8) {
4505                                 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
4506                         }
4507
4508                         allocation_size = (SMB_BIG_UINT)IVAL(pdata,0);
4509 #ifdef LARGE_SMB_OFF_T
4510                         allocation_size |= (((SMB_BIG_UINT)IVAL(pdata,4)) << 32);
4511 #else /* LARGE_SMB_OFF_T */
4512                         if (IVAL(pdata,4) != 0) {
4513                                 /* more than 32 bits? */
4514                                 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
4515                         }
4516 #endif /* LARGE_SMB_OFF_T */
4517                         DEBUG(10,("call_trans2setfilepathinfo: Set file allocation info for file %s to %.0f\n",
4518                                         fname, (double)allocation_size ));
4519
4520                         if (allocation_size) {
4521                                 allocation_size = smb_roundup(conn, allocation_size);
4522                         }
4523
4524                         if(allocation_size != get_file_size(sbuf)) {
4525                                 SMB_STRUCT_STAT new_sbuf;
4526
4527                                 DEBUG(10,("call_trans2setfilepathinfo: file %s : setting new allocation size to %.0f\n",
4528                                         fname, (double)allocation_size ));
4529
4530                                 if (fd == -1) {
4531                                         files_struct *new_fsp = NULL;
4532
4533                                         status = open_file_ntcreate(conn, fname, &sbuf,
4534                                                                         FILE_WRITE_DATA,
4535                                                                         FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
4536                                                                         FILE_OPEN,
4537                                                                         0,
4538                                                                         FILE_ATTRIBUTE_NORMAL,
4539                                                                         FORCE_OPLOCK_BREAK_TO_NONE,
4540                                                                         NULL, &new_fsp);
4541
4542                                         if (!NT_STATUS_IS_OK(status)) {
4543                                                 if (open_was_deferred(SVAL(inbuf,smb_mid))) {
4544                                                         /* We have re-scheduled this call. */
4545                                                         return -1;
4546                                                 }
4547                                                 return(UNIXERROR(ERRDOS,ERRnoaccess));
4548                                         }
4549                                         ret = vfs_allocate_file_space(new_fsp, allocation_size);
4550                                         if (SMB_VFS_FSTAT(new_fsp,new_fsp->fh->fd,&new_sbuf) != 0) {
4551                                                 DEBUG(3,("call_trans2setfilepathinfo: fstat of fnum %d failed (%s)\n",
4552                                                                         new_fsp->fnum, strerror(errno)));
4553                                                 ret = -1;
4554                                         }
4555                                         close_file(new_fsp,NORMAL_CLOSE);
4556                                 } else {
4557                                         ret = vfs_allocate_file_space(fsp, allocation_size);
4558                                         if (SMB_VFS_FSTAT(fsp,fd,&new_sbuf) != 0) {
4559                                                 DEBUG(3,("call_trans2setfilepathinfo: fstat of fnum %d failed (%s)\n",
4560                                                                         fsp->fnum, strerror(errno)));
4561                                                 ret = -1;
4562                                         }
4563                                 }
4564                                 if (ret == -1)
4565                                         return ERROR_NT(NT_STATUS_DISK_FULL);
4566
4567                                 /* Allocate can truncate size... */
4568                                 size = get_file_size(new_sbuf);
4569                         }
4570
4571                         break;
4572                 }
4573
4574                 case SMB_FILE_END_OF_FILE_INFORMATION:
4575                 case SMB_SET_FILE_END_OF_FILE_INFO:
4576                 {
4577                         if (total_data < 8) {
4578                                 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
4579                         }
4580
4581                         size = IVAL(pdata,0);
4582 #ifdef LARGE_SMB_OFF_T
4583                         size |= (((SMB_OFF_T)IVAL(pdata,4)) << 32);
4584 #else /* LARGE_SMB_OFF_T */
4585                         if (IVAL(pdata,4) != 0) {
4586                                 /* more than 32 bits? */
4587                                 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
4588                         }
4589 #endif /* LARGE_SMB_OFF_T */
4590                         DEBUG(10,("call_trans2setfilepathinfo: Set end of file info for file %s to %.0f\n", fname, (double)size ));
4591                         break;
4592                 }
4593
4594                 case SMB_FILE_DISPOSITION_INFORMATION:
4595                 case SMB_SET_FILE_DISPOSITION_INFO: /* Set delete on close for open file. */
4596                 {
4597 #if 0
4598                         /* JRA - We used to just ignore this on a path ?
4599                          * Shouldn't this be invalid level on a pathname
4600                          * based call ?
4601                          */
4602                         if (tran_call != TRANSACT2_SETFILEINFO) {
4603                                 return ERROR_NT(NT_STATUS_INVALID_LEVEL);
4604                         }
4605 #endif
4606                         return smb_set_file_disposition_info(conn,
4607                                                 outbuf,
4608                                                 bufsize,
4609                                                 params,
4610                                                 *ppdata,
4611                                                 total_data,
4612                                                 max_data_bytes,
4613                                                 fsp,
4614                                                 dosmode);
4615                 }
4616
4617                 case SMB_FILE_POSITION_INFORMATION:
4618                 {
4619                         return smb_file_position_information(conn,
4620                                                 outbuf,
4621                                                 bufsize,
4622                                                 params,
4623                                                 *ppdata,
4624                                                 total_data,
4625                                                 max_data_bytes,
4626                                                 fsp);
4627                 }
4628
4629                 /* From tridge Samba4 :
4630                  * MODE_INFORMATION in setfileinfo (I have no
4631                  * idea what "mode information" on a file is - it takes a value of 0,
4632                  * 2, 4 or 6. What could it be?).
4633                  */
4634
4635                 case SMB_FILE_MODE_INFORMATION:
4636                 {
4637                         return smb_file_mode_information(conn,
4638                                                 outbuf,
4639                                                 bufsize,
4640                                                 params,
4641                                                 *ppdata,
4642                                                 total_data,
4643                                                 max_data_bytes);
4644                 }
4645
4646                 /*
4647                  * CIFS UNIX extensions.
4648                  */
4649
4650                 case SMB_SET_FILE_UNIX_BASIC:
4651                 {
4652                         uint32 raw_unixmode;
4653                         BOOL delete_on_fail = False;
4654
4655                         if (total_data < 100) {
4656                                 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
4657                         }
4658
4659                         if(IVAL(pdata, 0) != SMB_SIZE_NO_CHANGE_LO &&
4660                            IVAL(pdata, 4) != SMB_SIZE_NO_CHANGE_HI) {
4661                                 size=IVAL(pdata,0); /* first 8 Bytes are size */
4662 #ifdef LARGE_SMB_OFF_T
4663                                 size |= (((SMB_OFF_T)IVAL(pdata,4)) << 32);
4664 #else /* LARGE_SMB_OFF_T */
4665                                 if (IVAL(pdata,4) != 0) {
4666                                         /* more than 32 bits? */
4667                                         return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
4668                                 }
4669 #endif /* LARGE_SMB_OFF_T */
4670                         }
4671                         pdata+=24;          /* ctime & st_blocks are not changed */
4672                         tvs.actime = convert_timespec_to_time_t(interpret_long_date(pdata)); /* access_time */
4673                         tvs.modtime = convert_timespec_to_time_t(interpret_long_date(pdata+8)); /* modification_time */
4674                         pdata+=16;
4675                         set_owner = (uid_t)IVAL(pdata,0);
4676                         pdata += 8;
4677                         set_grp = (gid_t)IVAL(pdata,0);
4678                         pdata += 8;
4679                         raw_unixmode = IVAL(pdata,28);
4680                         unixmode = unix_perms_from_wire(conn, &sbuf, raw_unixmode);
4681                         dosmode = 0; /* Ensure dos mode change doesn't override this. */
4682
4683                         DEBUG(10,("call_trans2setfilepathinfo: SMB_SET_FILE_UNIX_BASIC: name = %s \
4684 size = %.0f, uid = %u, gid = %u, raw perms = 0%o\n",
4685                                 fname, (double)size, (unsigned int)set_owner, (unsigned int)set_grp, (int)raw_unixmode));
4686
4687                         if (!VALID_STAT(sbuf)) {
4688
4689                                 /*
4690                                  * The only valid use of this is to create character and block
4691                                  * devices, and named pipes. This is deprecated (IMHO) and
4692                                  * a new info level should be used for mknod. JRA.
4693                                  */
4694
4695                                 uint32 file_type = IVAL(pdata,0);
4696 #if defined(HAVE_MAKEDEV)
4697                                 uint32 dev_major = IVAL(pdata,4);
4698                                 uint32 dev_minor = IVAL(pdata,12);
4699 #endif
4700
4701                                 SMB_DEV_T dev = (SMB_DEV_T)0;
4702
4703                                 if (tran_call == TRANSACT2_SETFILEINFO)
4704                                         return(ERROR_DOS(ERRDOS,ERRnoaccess));
4705
4706                                 if (raw_unixmode == SMB_MODE_NO_CHANGE) {
4707                                         return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
4708                                 }
4709
4710 #if defined(HAVE_MAKEDEV)
4711                                 dev = makedev(dev_major, dev_minor);
4712 #endif
4713
4714                                 switch (file_type) {
4715 #if defined(S_IFIFO)
4716                                         case UNIX_TYPE_FIFO:
4717                                                 unixmode |= S_IFIFO;
4718                                                 break;
4719 #endif
4720 #if defined(S_IFSOCK)
4721                                         case UNIX_TYPE_SOCKET:
4722                                                 unixmode |= S_IFSOCK;
4723                                                 break;
4724 #endif
4725 #if defined(S_IFCHR)
4726                                         case UNIX_TYPE_CHARDEV:
4727                                                 unixmode |= S_IFCHR;
4728                                                 break;
4729 #endif
4730 #if defined(S_IFBLK)
4731                                         case UNIX_TYPE_BLKDEV:
4732                                                 unixmode |= S_IFBLK;
4733                                                 break;
4734 #endif
4735                                         default:
4736                                                 return(ERROR_DOS(ERRDOS,ERRnoaccess));
4737                                 }
4738
4739                                 DEBUG(10,("call_trans2setfilepathinfo: SMB_SET_FILE_UNIX_BASIC doing mknod dev %.0f mode \
4740 0%o for file %s\n", (double)dev, unixmode, fname ));
4741
4742                                 /* Ok - do the mknod. */
4743                                 if (SMB_VFS_MKNOD(conn,fname, unixmode, dev) != 0) {
4744                                         return(UNIXERROR(ERRDOS,ERRnoaccess));
4745                                 }
4746
4747                                 /* If any of the other "set" calls fail we
4748                                  * don't want to end up with a half-constructed mknod.
4749                                  */
4750
4751                                 delete_on_fail = True;
4752
4753                                 if (lp_inherit_perms(SNUM(conn))) {
4754                                         inherit_access_acl(
4755                                                 conn, parent_dirname(fname),
4756                                                 fname, unixmode);
4757                                 }
4758
4759                                 if (SMB_VFS_STAT(conn, fname, &sbuf) != 0) {
4760                                         int saved_errno = errno;
4761                                         SMB_VFS_UNLINK(conn,fname);
4762                                         errno = saved_errno;
4763                                         return(UNIXERROR(ERRDOS,ERRnoaccess));
4764                                 }
4765
4766                                 /* Ensure we don't try and change anything else. */
4767                                 raw_unixmode = SMB_MODE_NO_CHANGE;
4768                                 size = get_file_size(sbuf);
4769                                 tvs.modtime = sbuf.st_mtime;
4770                                 tvs.actime = sbuf.st_atime;
4771                         }
4772
4773                         /*
4774                          * Deal with the UNIX specific mode set.
4775                          */
4776
4777                         if (raw_unixmode != SMB_MODE_NO_CHANGE) {
4778                                 DEBUG(10,("call_trans2setfilepathinfo: SMB_SET_FILE_UNIX_BASIC setting mode 0%o for file %s\n",
4779                                         (unsigned int)unixmode, fname ));
4780                                 if (SMB_VFS_CHMOD(conn,fname,unixmode) != 0)
4781                                         return(UNIXERROR(ERRDOS,ERRnoaccess));
4782                         }
4783
4784                         /*
4785                          * Deal with the UNIX specific uid set.
4786                          */
4787
4788                         if ((set_owner != (uid_t)SMB_UID_NO_CHANGE) && (sbuf.st_uid != set_owner)) {
4789                                 DEBUG(10,("call_trans2setfilepathinfo: SMB_SET_FILE_UNIX_BASIC changing owner %u for file %s\n",
4790                                         (unsigned int)set_owner, fname ));
4791                                 if (SMB_VFS_CHOWN(conn,fname,set_owner, (gid_t)-1) != 0) {
4792                                         if (delete_on_fail) {
4793                                                 int saved_errno = errno;
4794                                                 SMB_VFS_UNLINK(conn,fname);
4795                                                 errno = saved_errno;
4796                                         }
4797                                         return(UNIXERROR(ERRDOS,ERRnoaccess));
4798                                 }
4799                         }
4800
4801                         /*
4802                          * Deal with the UNIX specific gid set.
4803                          */
4804
4805                         if ((set_grp != (uid_t)SMB_GID_NO_CHANGE) && (sbuf.st_gid != set_grp)) {
4806                                 DEBUG(10,("call_trans2setfilepathinfo: SMB_SET_FILE_UNIX_BASIC changing group %u for file %s\n",
4807                                         (unsigned int)set_owner, fname ));
4808                                 if (SMB_VFS_CHOWN(conn,fname,(uid_t)-1, set_grp) != 0) {
4809                                         if (delete_on_fail) {
4810                                                 int saved_errno = errno;
4811                                                 SMB_VFS_UNLINK(conn,fname);
4812                                                 errno = saved_errno;
4813                                         }
4814                                         return(UNIXERROR(ERRDOS,ERRnoaccess));
4815                                 }
4816                         }
4817                         break;
4818                 }
4819
4820                 case SMB_SET_FILE_UNIX_LINK:
4821                 {
4822                         if (tran_call != TRANSACT2_SETPATHINFO) {
4823                                 /* We must have a pathname for this. */
4824                                 return ERROR_NT(NT_STATUS_INVALID_LEVEL);
4825                         }
4826                         return smb_set_file_unix_link(conn,
4827                                                 inbuf,
4828                                                 outbuf,
4829                                                 bufsize,
4830                                                 params,
4831                                                 *ppdata,
4832                                                 total_data,
4833                                                 max_data_bytes,
4834                                                 fname);
4835                 }
4836
4837                 case SMB_SET_FILE_UNIX_HLINK:
4838                 {
4839                         if (tran_call != TRANSACT2_SETPATHINFO) {
4840                                 /* We must have a pathname for this. */
4841                                 return ERROR_NT(NT_STATUS_INVALID_LEVEL);
4842                         }
4843                         return smb_set_file_unix_hlink(conn,
4844                                                 inbuf,
4845                                                 outbuf,
4846                                                 bufsize,
4847                                                 params,
4848                                                 *ppdata,
4849                                                 total_data,
4850                                                 max_data_bytes,
4851                                                 fname);
4852                 }
4853
4854                 case SMB_FILE_RENAME_INFORMATION:
4855                 {
4856                         return smb_file_rename_information(conn,
4857                                                         inbuf,
4858                                                         outbuf,
4859                                                         bufsize,
4860                                                         params,
4861                                                         pdata,
4862                                                         total_data,
4863                                                         max_data_bytes,
4864                                                         fsp,
4865                                                         fname);
4866                 }
4867
4868 #if defined(HAVE_POSIX_ACLS)
4869                 case SMB_SET_POSIX_ACL:
4870                 {
4871                         return smb_set_posix_acl(conn,
4872                                                 outbuf,
4873                                                 bufsize,
4874                                                 params,
4875                                                 pdata,
4876                                                 total_data,
4877                                                 max_data_bytes,
4878                                                 fsp,
4879                                                 fname);
4880                 }
4881 #endif
4882
4883                 case SMB_SET_POSIX_LOCK:
4884                 {
4885                         return smb_set_posix_lock(conn,
4886                                                 inbuf,
4887                                                 outbuf,
4888                                                 length,
4889                                                 bufsize,
4890                                                 params,
4891                                                 pdata,
4892                                                 total_data,
4893                                                 max_data_bytes,
4894                                                 fsp);
4895                 }
4896
4897                 default:
4898                         return ERROR_NT(NT_STATUS_INVALID_LEVEL);
4899         }
4900
4901         /* get some defaults (no modifications) if any info is zero or -1. */
4902         if (null_mtime(tvs.actime)) {
4903                 tvs.actime = sbuf.st_atime;
4904         }
4905
4906         if (null_mtime(tvs.modtime)) {
4907                 tvs.modtime = sbuf.st_mtime;
4908         }
4909
4910         DEBUG(6,("actime: %s " , ctime(&tvs.actime)));
4911         DEBUG(6,("modtime: %s ", ctime(&tvs.modtime)));
4912         DEBUG(6,("size: %.0f ", (double)size));
4913
4914         if (dosmode) {
4915                 if (S_ISDIR(sbuf.st_mode))
4916                         dosmode |= aDIR;
4917                 else
4918                         dosmode &= ~aDIR;
4919         }
4920
4921         DEBUG(6,("dosmode: %x\n"  , dosmode));
4922
4923         if(!((info_level == SMB_SET_FILE_END_OF_FILE_INFO) ||
4924                 (info_level == SMB_SET_FILE_ALLOCATION_INFO) ||
4925                 (info_level == SMB_FILE_ALLOCATION_INFORMATION) ||
4926                 (info_level == SMB_FILE_END_OF_FILE_INFORMATION))) {
4927
4928                 /*
4929                  * Only do this test if we are not explicitly
4930                  * changing the size of a file.
4931                  */
4932                 if (!size)
4933                         size = get_file_size(sbuf);
4934         }
4935
4936         /*
4937          * Try and set the times, size and mode of this file -
4938          * if they are different from the current values
4939          */
4940
4941         /* check the mode isn't different, before changing it */
4942         if ((dosmode != 0) && (dosmode != dos_mode(conn, fname, &sbuf))) {
4943
4944                 DEBUG(10,("call_trans2setfilepathinfo: file %s : setting dos mode %x\n", fname, dosmode ));
4945
4946                 if(file_set_dosmode(conn, fname, dosmode, &sbuf, False)) {
4947                         DEBUG(2,("file_set_dosmode of %s failed (%s)\n", fname, strerror(errno)));
4948                         return(UNIXERROR(ERRDOS,ERRnoaccess));
4949                 }
4950         }
4951
4952         /* Now the size. */
4953         if (size != get_file_size(sbuf)) {
4954
4955                 int ret;
4956
4957                 DEBUG(10,("call_trans2setfilepathinfo: file %s : setting new size to %.0f\n",
4958                         fname, (double)size ));
4959
4960                 if (fd == -1) {
4961                         files_struct *new_fsp = NULL;
4962
4963                         status = open_file_ntcreate(conn, fname, &sbuf,
4964                                                 FILE_WRITE_DATA,
4965                                                 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
4966                                                 FILE_OPEN,
4967                                                 0,
4968                                                 FILE_ATTRIBUTE_NORMAL,
4969                                                 FORCE_OPLOCK_BREAK_TO_NONE,
4970                                                 NULL, &new_fsp);
4971
4972                         if (!NT_STATUS_IS_OK(status)) {
4973                                 if (open_was_deferred(SVAL(inbuf,smb_mid))) {
4974                                         /* We have re-scheduled this call. */
4975                                         return -1;
4976                                 }
4977                                 return(UNIXERROR(ERRDOS,ERRnoaccess));
4978                         }
4979                         ret = vfs_set_filelen(new_fsp, size);
4980                         close_file(new_fsp,NORMAL_CLOSE);
4981                 } else {
4982                         ret = vfs_set_filelen(fsp, size);
4983                 }
4984
4985                 if (ret == -1) {
4986                         return (UNIXERROR(ERRHRD,ERRdiskfull));
4987                 }
4988         }
4989
4990         /*
4991          * Finally the times.
4992          */
4993         if (sbuf.st_mtime != tvs.modtime || sbuf.st_atime != tvs.actime) {
4994                 if(fsp != NULL) {
4995                         /*
4996                          * This was a setfileinfo on an open file.
4997                          * NT does this a lot. We also need to
4998                          * set the time here, as it can be read by
4999                          * FindFirst/FindNext and with the patch for bug #2045
5000                          * in smbd/fileio.c it ensures that this timestamp is
5001                          * kept sticky even after a write. We save the request
5002                          * away and will set it on file close and after a write. JRA.
5003                          */
5004
5005                         if (tvs.modtime != (time_t)0 && tvs.modtime != (time_t)-1) {
5006                                 DEBUG(10,("call_trans2setfilepathinfo: setting pending modtime to %s\n", ctime(&tvs.modtime) ));
5007                                 fsp_set_pending_modtime(fsp, tvs.modtime);
5008                         }
5009
5010                 }
5011                 DEBUG(10,("call_trans2setfilepathinfo: setting utimes to modified values.\n"));
5012
5013                 if(file_utime(conn, fname, &tvs)!=0) {
5014                         return(UNIXERROR(ERRDOS,ERRnoaccess));
5015                 }
5016         }
5017
5018         SSVAL(params,0,0);
5019         send_trans2_replies(outbuf, bufsize, params, 2, *ppdata, 0, max_data_bytes);
5020
5021         return(-1);
5022 }
5023
5024 /****************************************************************************
5025  Reply to a TRANS2_MKDIR (make directory with extended attributes).
5026 ****************************************************************************/
5027
5028 static int call_trans2mkdir(connection_struct *conn, char *inbuf, char *outbuf, int length, int bufsize,
5029                                         char **pparams, int total_params, char **ppdata, int total_data,
5030                                         unsigned int max_data_bytes)
5031 {
5032         char *params = *pparams;
5033         char *pdata = *ppdata;
5034         pstring directory;
5035         SMB_STRUCT_STAT sbuf;
5036         NTSTATUS status = NT_STATUS_OK;
5037         struct ea_list *ea_list = NULL;
5038
5039         if (!CAN_WRITE(conn))
5040                 return ERROR_DOS(ERRSRV,ERRaccess);
5041
5042         if (total_params < 5) {
5043                 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
5044         }
5045
5046         srvstr_get_path(inbuf, directory, &params[4], sizeof(directory), total_params - 4, STR_TERMINATE, &status);
5047         if (!NT_STATUS_IS_OK(status)) {
5048                 return ERROR_NT(status);
5049         }
5050
5051         DEBUG(3,("call_trans2mkdir : name = %s\n", directory));
5052
5053         status = unix_convert(conn, directory, False, NULL, &sbuf);
5054         if (!NT_STATUS_IS_OK(status)) {
5055                 return ERROR_NT(status);
5056         }
5057
5058         /* Any data in this call is an EA list. */
5059         if (total_data && (total_data != 4) && !lp_ea_support(SNUM(conn))) {
5060                 return ERROR_NT(NT_STATUS_EAS_NOT_SUPPORTED);
5061         }
5062
5063         /*
5064          * OS/2 workplace shell seems to send SET_EA requests of "null"
5065          * length (4 bytes containing IVAL 4).
5066          * They seem to have no effect. Bug #3212. JRA.
5067          */
5068
5069         if (total_data != 4) {
5070                 if (total_data < 10) {
5071                         return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
5072                 }
5073
5074                 if (IVAL(pdata,0) > total_data) {
5075                         DEBUG(10,("call_trans2mkdir: bad total data size (%u) > %u\n",
5076                                 IVAL(pdata,0), (unsigned int)total_data));
5077                         return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
5078                 }
5079
5080                 ea_list = read_ea_list(tmp_talloc_ctx(), pdata + 4,
5081                                        total_data - 4);
5082                 if (!ea_list) {
5083                         return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
5084                 }
5085         } else if (IVAL(pdata,0) != 4) {
5086                 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
5087         }
5088
5089         status = check_name(conn, directory);
5090         if (!NT_STATUS_IS_OK(status)) {
5091                 DEBUG(5,("call_trans2mkdir error (%s)\n", nt_errstr(status)));
5092                 return ERROR_NT(status);
5093         }
5094
5095         status = create_directory(conn, directory);
5096
5097         if (!NT_STATUS_IS_OK(status)) {
5098                 return ERROR_NT(status);
5099         }
5100
5101         /* Try and set any given EA. */
5102         if (ea_list) {
5103                 status = set_ea(conn, NULL, directory, ea_list);
5104                 if (!NT_STATUS_IS_OK(status)) {
5105                         return ERROR_NT(status);
5106                 }
5107         }
5108
5109         /* Realloc the parameter and data sizes */
5110         *pparams = (char *)SMB_REALLOC(*pparams,2);
5111         if(*pparams == NULL) {
5112                 return ERROR_NT(NT_STATUS_NO_MEMORY);
5113         }
5114         params = *pparams;
5115
5116         SSVAL(params,0,0);
5117
5118         send_trans2_replies(outbuf, bufsize, params, 2, *ppdata, 0, max_data_bytes);
5119
5120         return(-1);
5121 }
5122
5123 /****************************************************************************
5124  Reply to a TRANS2_FINDNOTIFYFIRST (start monitoring a directory for changes).
5125  We don't actually do this - we just send a null response.
5126 ****************************************************************************/
5127
5128 static int call_trans2findnotifyfirst(connection_struct *conn, char *inbuf, char *outbuf, int length, int bufsize,
5129                                         char **pparams, int total_params, char **ppdata, int total_data,
5130                                         unsigned int max_data_bytes)
5131 {
5132         static uint16 fnf_handle = 257;
5133         char *params = *pparams;
5134         uint16 info_level;
5135
5136         if (total_params < 6) {
5137                 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
5138         }
5139
5140         info_level = SVAL(params,4);
5141         DEBUG(3,("call_trans2findnotifyfirst - info_level %d\n", info_level));
5142
5143         switch (info_level) {
5144                 case 1:
5145                 case 2:
5146                         break;
5147                 default:
5148                         return ERROR_NT(NT_STATUS_INVALID_LEVEL);
5149         }
5150
5151         /* Realloc the parameter and data sizes */
5152         *pparams = (char *)SMB_REALLOC(*pparams,6);
5153         if (*pparams == NULL) {
5154                 return ERROR_NT(NT_STATUS_NO_MEMORY);
5155         }
5156         params = *pparams;
5157
5158         SSVAL(params,0,fnf_handle);
5159         SSVAL(params,2,0); /* No changes */
5160         SSVAL(params,4,0); /* No EA errors */
5161
5162         fnf_handle++;
5163
5164         if(fnf_handle == 0)
5165                 fnf_handle = 257;
5166
5167         send_trans2_replies(outbuf, bufsize, params, 6, *ppdata, 0, max_data_bytes);
5168
5169         return(-1);
5170 }
5171
5172 /****************************************************************************
5173  Reply to a TRANS2_FINDNOTIFYNEXT (continue monitoring a directory for
5174  changes). Currently this does nothing.
5175 ****************************************************************************/
5176
5177 static int call_trans2findnotifynext(connection_struct *conn, char *inbuf, char *outbuf, int length, int bufsize,
5178                                         char **pparams, int total_params, char **ppdata, int total_data,
5179                                         unsigned int max_data_bytes)
5180 {
5181         char *params = *pparams;
5182
5183         DEBUG(3,("call_trans2findnotifynext\n"));
5184
5185         /* Realloc the parameter and data sizes */
5186         *pparams = (char *)SMB_REALLOC(*pparams,4);
5187         if (*pparams == NULL) {
5188                 return ERROR_NT(NT_STATUS_NO_MEMORY);
5189         }
5190         params = *pparams;
5191
5192         SSVAL(params,0,0); /* No changes */
5193         SSVAL(params,2,0); /* No EA errors */
5194
5195         send_trans2_replies(outbuf, bufsize, params, 4, *ppdata, 0, max_data_bytes);
5196
5197         return(-1);
5198 }
5199
5200 /****************************************************************************
5201  Reply to a TRANS2_GET_DFS_REFERRAL - Shirish Kalele <kalele@veritas.com>.
5202 ****************************************************************************/
5203
5204 static int call_trans2getdfsreferral(connection_struct *conn, char* inbuf, char* outbuf, int length, int bufsize,
5205                                         char **pparams, int total_params, char **ppdata, int total_data,
5206                                         unsigned int max_data_bytes)
5207 {
5208         char *params = *pparams;
5209         pstring pathname;
5210         int reply_size = 0;
5211         int max_referral_level;
5212
5213         DEBUG(10,("call_trans2getdfsreferral\n"));
5214
5215         if (total_params < 3) {
5216                 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
5217         }
5218
5219         max_referral_level = SVAL(params,0);
5220
5221         if(!lp_host_msdfs())
5222                 return ERROR_DOS(ERRDOS,ERRbadfunc);
5223
5224         srvstr_pull(inbuf, pathname, &params[2], sizeof(pathname), total_params - 2, STR_TERMINATE);
5225         if((reply_size = setup_dfs_referral(conn, pathname,max_referral_level,ppdata)) < 0)
5226                 return UNIXERROR(ERRDOS,ERRbadfile);
5227
5228         SSVAL(outbuf,smb_flg2,SVAL(outbuf,smb_flg2) | FLAGS2_DFS_PATHNAMES);
5229         send_trans2_replies(outbuf,bufsize,0,0,*ppdata,reply_size, max_data_bytes);
5230
5231         return(-1);
5232 }
5233
5234 #define LMCAT_SPL       0x53
5235 #define LMFUNC_GETJOBID 0x60
5236
5237 /****************************************************************************
5238  Reply to a TRANS2_IOCTL - used for OS/2 printing.
5239 ****************************************************************************/
5240
5241 static int call_trans2ioctl(connection_struct *conn, char* inbuf, char* outbuf, int length, int bufsize,
5242                                         char **pparams, int total_params, char **ppdata, int total_data,
5243                                         unsigned int max_data_bytes)
5244 {
5245         char *pdata = *ppdata;
5246         files_struct *fsp = file_fsp(inbuf,smb_vwv15);
5247
5248         /* check for an invalid fid before proceeding */
5249
5250         if (!fsp)
5251                 return(ERROR_DOS(ERRDOS,ERRbadfid));
5252
5253         if ((SVAL(inbuf,(smb_setup+4)) == LMCAT_SPL) &&
5254                         (SVAL(inbuf,(smb_setup+6)) == LMFUNC_GETJOBID)) {
5255                 *ppdata = (char *)SMB_REALLOC(*ppdata, 32);
5256                 if (*ppdata == NULL) {
5257                         return ERROR_NT(NT_STATUS_NO_MEMORY);
5258                 }
5259                 pdata = *ppdata;
5260
5261                 /* NOTE - THIS IS ASCII ONLY AT THE MOMENT - NOT SURE IF OS/2
5262                         CAN ACCEPT THIS IN UNICODE. JRA. */
5263
5264                 SSVAL(pdata,0,fsp->rap_print_jobid);                     /* Job number */
5265                 srvstr_push( outbuf, pdata + 2, global_myname(), 15, STR_ASCII|STR_TERMINATE); /* Our NetBIOS name */
5266                 srvstr_push( outbuf, pdata+18, lp_servicename(SNUM(conn)), 13, STR_ASCII|STR_TERMINATE); /* Service name */
5267                 send_trans2_replies(outbuf,bufsize,*pparams,0,*ppdata,32, max_data_bytes);
5268                 return(-1);
5269         } else {
5270                 DEBUG(2,("Unknown TRANS2_IOCTL\n"));
5271                 return ERROR_DOS(ERRSRV,ERRerror);
5272         }
5273 }
5274
5275 /****************************************************************************
5276  Reply to a SMBfindclose (stop trans2 directory search).
5277 ****************************************************************************/
5278
5279 int reply_findclose(connection_struct *conn,
5280                     char *inbuf,char *outbuf,int length,int bufsize)
5281 {
5282         int outsize = 0;
5283         int dptr_num=SVALS(inbuf,smb_vwv0);
5284         START_PROFILE(SMBfindclose);
5285
5286         DEBUG(3,("reply_findclose, dptr_num = %d\n", dptr_num));
5287
5288         dptr_close(&dptr_num);
5289
5290         outsize = set_message(outbuf,0,0,False);
5291
5292         DEBUG(3,("SMBfindclose dptr_num = %d\n", dptr_num));
5293
5294         END_PROFILE(SMBfindclose);
5295         return(outsize);
5296 }
5297
5298 /****************************************************************************
5299  Reply to a SMBfindnclose (stop FINDNOTIFYFIRST directory search).
5300 ****************************************************************************/
5301
5302 int reply_findnclose(connection_struct *conn,
5303                      char *inbuf,char *outbuf,int length,int bufsize)
5304 {
5305         int outsize = 0;
5306         int dptr_num= -1;
5307         START_PROFILE(SMBfindnclose);
5308
5309         dptr_num = SVAL(inbuf,smb_vwv0);
5310
5311         DEBUG(3,("reply_findnclose, dptr_num = %d\n", dptr_num));
5312
5313         /* We never give out valid handles for a
5314            findnotifyfirst - so any dptr_num is ok here.
5315            Just ignore it. */
5316
5317         outsize = set_message(outbuf,0,0,False);
5318
5319         DEBUG(3,("SMB_findnclose dptr_num = %d\n", dptr_num));
5320
5321         END_PROFILE(SMBfindnclose);
5322         return(outsize);
5323 }
5324
5325 int handle_trans2(connection_struct *conn,
5326                   struct trans_state *state,
5327                   char *inbuf, char *outbuf, int size, int bufsize)
5328 {
5329         int outsize;
5330
5331         if (Protocol >= PROTOCOL_NT1) {
5332                 SSVAL(outbuf,smb_flg2,SVAL(outbuf,smb_flg2) | 0x40); /* IS_LONG_NAME */
5333         }
5334
5335         /* Now we must call the relevant TRANS2 function */
5336         switch(state->call)  {
5337         case TRANSACT2_OPEN:
5338         {
5339                 START_PROFILE(Trans2_open);
5340                 outsize = call_trans2open(
5341                         conn, inbuf, outbuf, bufsize,
5342                         &state->param, state->total_param,
5343                         &state->data, state->total_data,
5344                         state->max_data_return);
5345                 END_PROFILE(Trans2_open);
5346                 break;
5347         }
5348
5349         case TRANSACT2_FINDFIRST:
5350         {
5351                 START_PROFILE(Trans2_findfirst);
5352                 outsize = call_trans2findfirst(
5353                         conn, inbuf, outbuf, bufsize,
5354                         &state->param, state->total_param,
5355                         &state->data, state->total_data,
5356                         state->max_data_return);
5357                 END_PROFILE(Trans2_findfirst);
5358                 break;
5359         }
5360
5361         case TRANSACT2_FINDNEXT:
5362         {
5363                 START_PROFILE(Trans2_findnext);
5364                 outsize = call_trans2findnext(
5365                         conn, inbuf, outbuf, size, bufsize,
5366                         &state->param, state->total_param,
5367                         &state->data, state->total_data,
5368                         state->max_data_return);
5369                 END_PROFILE(Trans2_findnext);
5370                 break;
5371         }
5372
5373         case TRANSACT2_QFSINFO:
5374         {
5375                 START_PROFILE(Trans2_qfsinfo);
5376                 outsize = call_trans2qfsinfo(
5377                         conn, inbuf, outbuf, size, bufsize,
5378                         &state->param, state->total_param,
5379                         &state->data, state->total_data,
5380                         state->max_data_return);
5381                 END_PROFILE(Trans2_qfsinfo);
5382             break;
5383         }
5384
5385         case TRANSACT2_SETFSINFO:
5386         {
5387                 START_PROFILE(Trans2_setfsinfo);
5388                 outsize = call_trans2setfsinfo(
5389                         conn, inbuf, outbuf, size, bufsize,
5390                         &state->param, state->total_param,
5391                         &state->data, state->total_data,
5392                         state->max_data_return);
5393                 END_PROFILE(Trans2_setfsinfo);
5394                 break;
5395         }
5396
5397         case TRANSACT2_QPATHINFO:
5398         case TRANSACT2_QFILEINFO:
5399         {
5400                 START_PROFILE(Trans2_qpathinfo);
5401                 outsize = call_trans2qfilepathinfo(
5402                         conn, inbuf, outbuf, size, bufsize, state->call,
5403                         &state->param, state->total_param,
5404                         &state->data, state->total_data,
5405                         state->max_data_return);
5406                 END_PROFILE(Trans2_qpathinfo);
5407                 break;
5408         }
5409
5410         case TRANSACT2_SETPATHINFO:
5411         case TRANSACT2_SETFILEINFO:
5412         {
5413                 START_PROFILE(Trans2_setpathinfo);
5414                 outsize = call_trans2setfilepathinfo(
5415                         conn, inbuf, outbuf, size, bufsize, state->call,
5416                         &state->param, state->total_param,
5417                         &state->data, state->total_data,
5418                         state->max_data_return);
5419                 END_PROFILE(Trans2_setpathinfo);
5420                 break;
5421         }
5422
5423         case TRANSACT2_FINDNOTIFYFIRST:
5424         {
5425                 START_PROFILE(Trans2_findnotifyfirst);
5426                 outsize = call_trans2findnotifyfirst(
5427                         conn, inbuf, outbuf, size, bufsize,
5428                         &state->param, state->total_param,
5429                         &state->data, state->total_data,
5430                         state->max_data_return);
5431                 END_PROFILE(Trans2_findnotifyfirst);
5432                 break;
5433         }
5434
5435         case TRANSACT2_FINDNOTIFYNEXT:
5436         {
5437                 START_PROFILE(Trans2_findnotifynext);
5438                 outsize = call_trans2findnotifynext(
5439                         conn, inbuf, outbuf, size, bufsize,
5440                         &state->param, state->total_param,
5441                         &state->data, state->total_data,
5442                         state->max_data_return);
5443                 END_PROFILE(Trans2_findnotifynext);
5444                 break;
5445         }
5446
5447         case TRANSACT2_MKDIR:
5448         {
5449                 START_PROFILE(Trans2_mkdir);
5450                 outsize = call_trans2mkdir(
5451                         conn, inbuf, outbuf, size, bufsize,
5452                         &state->param, state->total_param,
5453                         &state->data, state->total_data,
5454                         state->max_data_return);
5455                 END_PROFILE(Trans2_mkdir);
5456                 break;
5457         }
5458
5459         case TRANSACT2_GET_DFS_REFERRAL:
5460         {
5461                 START_PROFILE(Trans2_get_dfs_referral);
5462                 outsize = call_trans2getdfsreferral(
5463                         conn, inbuf, outbuf, size, bufsize,
5464                         &state->param, state->total_param,
5465                         &state->data, state->total_data,
5466                         state->max_data_return);
5467                 END_PROFILE(Trans2_get_dfs_referral);
5468                 break;
5469         }
5470
5471         case TRANSACT2_IOCTL:
5472         {
5473                 START_PROFILE(Trans2_ioctl);
5474                 outsize = call_trans2ioctl(
5475                         conn, inbuf, outbuf, size, bufsize,
5476                         &state->param, state->total_param,
5477                         &state->data, state->total_data,
5478                         state->max_data_return);
5479                 END_PROFILE(Trans2_ioctl);
5480                 break;
5481         }
5482
5483         default:
5484                 /* Error in request */
5485                 DEBUG(2,("Unknown request %d in trans2 call\n", state->call));
5486                 outsize = ERROR_DOS(ERRSRV,ERRerror);
5487         }
5488
5489         return outsize;
5490 }
5491
5492 /****************************************************************************
5493  Reply to a SMBtrans2.
5494  ****************************************************************************/
5495
5496 int reply_trans2(connection_struct *conn, char *inbuf,char *outbuf,
5497                  int size, int bufsize)
5498 {
5499         int outsize = 0;
5500         unsigned int dsoff = SVAL(inbuf, smb_dsoff);
5501         unsigned int dscnt = SVAL(inbuf, smb_dscnt);
5502         unsigned int psoff = SVAL(inbuf, smb_psoff);
5503         unsigned int pscnt = SVAL(inbuf, smb_pscnt);
5504         unsigned int tran_call = SVAL(inbuf, smb_setup0);
5505         struct trans_state *state;
5506         NTSTATUS result;
5507
5508         START_PROFILE(SMBtrans2);
5509
5510         result = allow_new_trans(conn->pending_trans, SVAL(inbuf, smb_mid));
5511         if (!NT_STATUS_IS_OK(result)) {
5512                 DEBUG(2, ("Got invalid trans2 request: %s\n",
5513                           nt_errstr(result)));
5514                 END_PROFILE(SMBtrans2);
5515                 return ERROR_NT(result);
5516         }
5517
5518         if (IS_IPC(conn) && (tran_call != TRANSACT2_OPEN)
5519             && (tran_call != TRANSACT2_GET_DFS_REFERRAL)) {
5520                 END_PROFILE(SMBtrans2);
5521                 return ERROR_DOS(ERRSRV,ERRaccess);
5522         }
5523
5524         if ((state = TALLOC_P(conn->mem_ctx, struct trans_state)) == NULL) {
5525                 DEBUG(0, ("talloc failed\n"));
5526                 END_PROFILE(SMBtrans2);
5527                 return ERROR_NT(NT_STATUS_NO_MEMORY);
5528         }
5529
5530         state->cmd = SMBtrans2;
5531
5532         state->mid = SVAL(inbuf, smb_mid);
5533         state->vuid = SVAL(inbuf, smb_uid);
5534         state->setup_count = SVAL(inbuf, smb_suwcnt);
5535         state->setup = NULL;
5536         state->total_param = SVAL(inbuf, smb_tpscnt);
5537         state->param = NULL;
5538         state->total_data =  SVAL(inbuf, smb_tdscnt);
5539         state->data = NULL;
5540         state->max_param_return = SVAL(inbuf, smb_mprcnt);
5541         state->max_data_return  = SVAL(inbuf, smb_mdrcnt);
5542         state->max_setup_return = SVAL(inbuf, smb_msrcnt);
5543         state->close_on_completion = BITSETW(inbuf+smb_vwv5,0);
5544         state->one_way = BITSETW(inbuf+smb_vwv5,1);
5545
5546         state->call = tran_call;
5547
5548         /* All trans2 messages we handle have smb_sucnt == 1 - ensure this
5549            is so as a sanity check */
5550         if (state->setup_count != 1) {
5551                 /*
5552                  * Need to have rc=0 for ioctl to get job id for OS/2.
5553                  *  Network printing will fail if function is not successful.
5554                  *  Similar function in reply.c will be used if protocol
5555                  *  is LANMAN1.0 instead of LM1.2X002.
5556                  *  Until DosPrintSetJobInfo with PRJINFO3 is supported,
5557                  *  outbuf doesn't have to be set(only job id is used).
5558                  */
5559                 if ( (state->setup_count == 4) && (tran_call == TRANSACT2_IOCTL) &&
5560                                 (SVAL(inbuf,(smb_setup+4)) == LMCAT_SPL) &&
5561                                 (SVAL(inbuf,(smb_setup+6)) == LMFUNC_GETJOBID)) {
5562                         DEBUG(2,("Got Trans2 DevIOctl jobid\n"));
5563                 } else {
5564                         DEBUG(2,("Invalid smb_sucnt in trans2 call(%u)\n",state->setup_count));
5565                         DEBUG(2,("Transaction is %d\n",tran_call));
5566                         TALLOC_FREE(state);
5567                         END_PROFILE(SMBtrans2);
5568                         return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
5569                 }
5570         }
5571
5572         if ((dscnt > state->total_data) || (pscnt > state->total_param))
5573                 goto bad_param;
5574
5575         if (state->total_data) {
5576                 /* Can't use talloc here, the core routines do realloc on the
5577                  * params and data. */
5578                 state->data = (char *)SMB_MALLOC(state->total_data);
5579                 if (state->data == NULL) {
5580                         DEBUG(0,("reply_trans2: data malloc fail for %u "
5581                                  "bytes !\n", (unsigned int)state->total_data));
5582                         TALLOC_FREE(state);
5583                         END_PROFILE(SMBtrans2);
5584                         return(ERROR_DOS(ERRDOS,ERRnomem));
5585                 }
5586                 if ((dsoff+dscnt < dsoff) || (dsoff+dscnt < dscnt))
5587                         goto bad_param;
5588                 if ((smb_base(inbuf)+dsoff+dscnt > inbuf + size) ||
5589                     (smb_base(inbuf)+dsoff+dscnt < smb_base(inbuf)))
5590                         goto bad_param;
5591
5592                 memcpy(state->data,smb_base(inbuf)+dsoff,dscnt);
5593         }
5594
5595         if (state->total_param) {
5596                 /* Can't use talloc here, the core routines do realloc on the
5597                  * params and data. */
5598                 state->param = (char *)SMB_MALLOC(state->total_param);
5599                 if (state->param == NULL) {
5600                         DEBUG(0,("reply_trans: param malloc fail for %u "
5601                                  "bytes !\n", (unsigned int)state->total_param));
5602                         SAFE_FREE(state->data);
5603                         TALLOC_FREE(state);
5604                         END_PROFILE(SMBtrans2);
5605                         return(ERROR_DOS(ERRDOS,ERRnomem));
5606                 }
5607                 if ((psoff+pscnt < psoff) || (psoff+pscnt < pscnt))
5608                         goto bad_param;
5609                 if ((smb_base(inbuf)+psoff+pscnt > inbuf + size) ||
5610                     (smb_base(inbuf)+psoff+pscnt < smb_base(inbuf)))
5611                         goto bad_param;
5612
5613                 memcpy(state->param,smb_base(inbuf)+psoff,pscnt);
5614         }
5615
5616         state->received_data  = dscnt;
5617         state->received_param = pscnt;
5618
5619         if ((state->received_param == state->total_param) &&
5620             (state->received_data == state->total_data)) {
5621
5622                 outsize = handle_trans2(conn, state, inbuf, outbuf,
5623                                         size, bufsize);
5624                 SAFE_FREE(state->data);
5625                 SAFE_FREE(state->param);
5626                 TALLOC_FREE(state);
5627                 END_PROFILE(SMBtrans2);
5628                 return outsize;
5629         }
5630
5631         DLIST_ADD(conn->pending_trans, state);
5632
5633         /* We need to send an interim response then receive the rest
5634            of the parameter/data bytes */
5635         outsize = set_message(outbuf,0,0,False);
5636         show_msg(outbuf);
5637         END_PROFILE(SMBtrans2);
5638         return outsize;
5639
5640   bad_param:
5641
5642         DEBUG(0,("reply_trans2: invalid trans parameters\n"));
5643         SAFE_FREE(state->data);
5644         SAFE_FREE(state->param);
5645         TALLOC_FREE(state);
5646         END_PROFILE(SMBtrans2);
5647         return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
5648 }
5649
5650
5651 /****************************************************************************
5652  Reply to a SMBtranss2
5653  ****************************************************************************/
5654
5655 int reply_transs2(connection_struct *conn,
5656                   char *inbuf,char *outbuf,int size,int bufsize)
5657 {
5658         int outsize = 0;
5659         unsigned int pcnt,poff,dcnt,doff,pdisp,ddisp;
5660         struct trans_state *state;
5661
5662         START_PROFILE(SMBtranss2);
5663
5664         show_msg(inbuf);
5665
5666         for (state = conn->pending_trans; state != NULL;
5667              state = state->next) {
5668                 if (state->mid == SVAL(inbuf,smb_mid)) {
5669                         break;
5670                 }
5671         }
5672
5673         if ((state == NULL) || (state->cmd != SMBtrans2)) {
5674                 END_PROFILE(SMBtranss2);
5675                 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
5676         }
5677
5678         /* Revise state->total_param and state->total_data in case they have
5679            changed downwards */
5680
5681         if (SVAL(inbuf, smb_tpscnt) < state->total_param)
5682                 state->total_param = SVAL(inbuf, smb_tpscnt);
5683         if (SVAL(inbuf, smb_tdscnt) < state->total_data)
5684                 state->total_data = SVAL(inbuf, smb_tdscnt);
5685
5686         pcnt = SVAL(inbuf, smb_spscnt);
5687         poff = SVAL(inbuf, smb_spsoff);
5688         pdisp = SVAL(inbuf, smb_spsdisp);
5689
5690         dcnt = SVAL(inbuf, smb_sdscnt);
5691         doff = SVAL(inbuf, smb_sdsoff);
5692         ddisp = SVAL(inbuf, smb_sdsdisp);
5693
5694         state->received_param += pcnt;
5695         state->received_data += dcnt;
5696
5697         if ((state->received_data > state->total_data) ||
5698             (state->received_param > state->total_param))
5699                 goto bad_param;
5700
5701         if (pcnt) {
5702                 if (pdisp+pcnt > state->total_param)
5703                         goto bad_param;
5704                 if ((pdisp+pcnt < pdisp) || (pdisp+pcnt < pcnt))
5705                         goto bad_param;
5706                 if (pdisp > state->total_param)
5707                         goto bad_param;
5708                 if ((smb_base(inbuf) + poff + pcnt > inbuf + size) ||
5709                     (smb_base(inbuf) + poff + pcnt < smb_base(inbuf)))
5710                         goto bad_param;
5711                 if (state->param + pdisp < state->param)
5712                         goto bad_param;
5713
5714                 memcpy(state->param+pdisp,smb_base(inbuf)+poff,
5715                        pcnt);
5716         }
5717
5718         if (dcnt) {
5719                 if (ddisp+dcnt > state->total_data)
5720                         goto bad_param;
5721                 if ((ddisp+dcnt < ddisp) || (ddisp+dcnt < dcnt))
5722                         goto bad_param;
5723                 if (ddisp > state->total_data)
5724                         goto bad_param;
5725                 if ((smb_base(inbuf) + doff + dcnt > inbuf + size) ||
5726                     (smb_base(inbuf) + doff + dcnt < smb_base(inbuf)))
5727                         goto bad_param;
5728                 if (state->data + ddisp < state->data)
5729                         goto bad_param;
5730
5731                 memcpy(state->data+ddisp, smb_base(inbuf)+doff,
5732                        dcnt);
5733         }
5734
5735         if ((state->received_param < state->total_param) ||
5736             (state->received_data < state->total_data)) {
5737                 END_PROFILE(SMBtranss2);
5738                 return -1;
5739         }
5740
5741         /* construct_reply_common has done us the favor to pre-fill the
5742          * command field with SMBtranss2 which is wrong :-)
5743          */
5744         SCVAL(outbuf,smb_com,SMBtrans2);
5745
5746         outsize = handle_trans2(conn, state, inbuf, outbuf, size, bufsize);
5747
5748         DLIST_REMOVE(conn->pending_trans, state);
5749         SAFE_FREE(state->data);
5750         SAFE_FREE(state->param);
5751         TALLOC_FREE(state);
5752
5753         if (outsize == 0) {
5754                 END_PROFILE(SMBtranss2);
5755                 return(ERROR_DOS(ERRSRV,ERRnosupport));
5756         }
5757
5758         END_PROFILE(SMBtranss2);
5759         return(outsize);
5760
5761   bad_param:
5762
5763         DEBUG(0,("reply_transs2: invalid trans parameters\n"));
5764         DLIST_REMOVE(conn->pending_trans, state);
5765         SAFE_FREE(state->data);
5766         SAFE_FREE(state->param);
5767         TALLOC_FREE(state);
5768         END_PROFILE(SMBtranss2);
5769         return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
5770 }