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