source/smbd/trans2.c

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