source3/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 void call_trans2qpipeinfo(connection_struct *conn,
3342                                  struct smb_request *req,
3343                                  unsigned int tran_call,
3344                                  char **pparams, int total_params,
3345                                  char **ppdata, int total_data,
3346                                  unsigned int max_data_bytes)
3347 {
3348         char *params = *pparams;
3349         char *pdata = *ppdata;
3350         unsigned int data_size = 0;
3351         unsigned int param_size = 2;
3352         uint16 info_level;
3353         smb_np_struct *p_pipe = NULL;
3354
3355         if (!params) {
3356                 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
3357                 return;
3358         }
3359
3360         if (total_params < 4) {
3361                 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
3362                 return;
3363         }
3364
3365         p_pipe = get_rpc_pipe_p(SVAL(params,0));
3366         if (p_pipe == NULL) {
3367                 reply_nterror(req, NT_STATUS_INVALID_HANDLE);
3368                 return;
3369         }
3370
3371         info_level = SVAL(params,2);
3372
3373         *pparams = (char *)SMB_REALLOC(*pparams,2);
3374         if (*pparams == NULL) {
3375                 reply_nterror(req, NT_STATUS_NO_MEMORY);
3376                 return;
3377         }
3378         params = *pparams;
3379         SSVAL(params,0,0);
3380         data_size = max_data_bytes + DIR_ENTRY_SAFETY_MARGIN;
3381         *ppdata = (char *)SMB_REALLOC(*ppdata, data_size);
3382         if (*ppdata == NULL ) {
3383                 reply_nterror(req, NT_STATUS_NO_MEMORY);
3384                 return;
3385         }
3386         pdata = *ppdata;
3387
3388         switch (info_level) {
3389                 case SMB_FILE_STANDARD_INFORMATION:
3390                         memset(pdata,24,0);
3391                         SOFF_T(pdata,0,4096LL);
3392                         SIVAL(pdata,16,1);
3393                         SIVAL(pdata,20,1);
3394                         data_size = 24;
3395                         break;
3396
3397                 default:
3398                         reply_nterror(req, NT_STATUS_INVALID_LEVEL);
3399                         return;
3400         }
3401
3402         send_trans2_replies_new(req, params, param_size, *ppdata, data_size,
3403                                 max_data_bytes);
3404
3405         return;
3406 }
3407
3408 /****************************************************************************
3409  Reply to a TRANS2_QFILEPATHINFO or TRANSACT2_QFILEINFO (query file info by
3410  file name or file id).
3411 ****************************************************************************/
3412
3413 static void call_trans2qfilepathinfo(connection_struct *conn,
3414                                      struct smb_request *req,
3415                                      unsigned int tran_call,
3416                                      char **pparams, int total_params,
3417                                      char **ppdata, int total_data,
3418                                      unsigned int max_data_bytes)
3419 {
3420         char *params = *pparams;
3421         char *pdata = *ppdata;
3422         char *dstart, *dend;
3423         uint16 info_level;
3424         int mode=0;
3425         int nlink;
3426         SMB_OFF_T file_size=0;
3427         SMB_BIG_UINT allocation_size=0;
3428         unsigned int data_size = 0;
3429         unsigned int param_size = 2;
3430         SMB_STRUCT_STAT sbuf;
3431         pstring fname, dos_fname;
3432         char *fullpathname;
3433         char *base_name;
3434         char *p;
3435         SMB_OFF_T pos = 0;
3436         BOOL delete_pending = False;
3437         int len;
3438         time_t create_time, mtime, atime;
3439         struct timespec create_time_ts, mtime_ts, atime_ts;
3440         files_struct *fsp = NULL;
3441         struct file_id fileid;
3442         TALLOC_CTX *data_ctx = NULL;
3443         struct ea_list *ea_list = NULL;
3444         uint32 access_mask = 0x12019F; /* Default - GENERIC_EXECUTE mapping from Windows */
3445         char *lock_data = NULL;
3446
3447         if (!params) {
3448                 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
3449                 return;
3450         }
3451
3452         ZERO_STRUCT(sbuf);
3453
3454         if (tran_call == TRANSACT2_QFILEINFO) {
3455                 if (total_params < 4) {
3456                         reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
3457                         return;
3458                 }
3459
3460                 if (IS_IPC(conn)) {
3461                         call_trans2qpipeinfo(conn, req, tran_call,
3462                                              pparams, total_params,
3463                                              ppdata, total_data,
3464                                              max_data_bytes);
3465                         return;
3466                 }
3467
3468                 fsp = file_fsp(SVAL(params,0));
3469                 info_level = SVAL(params,2);
3470
3471                 DEBUG(3,("call_trans2qfilepathinfo: TRANSACT2_QFILEINFO: level = %d\n", info_level));
3472
3473                 if (INFO_LEVEL_IS_UNIX(info_level) && !lp_unix_extensions()) {
3474                         reply_nterror(req, NT_STATUS_INVALID_LEVEL);
3475                         return;
3476                 }
3477
3478                 if(fsp && (fsp->fake_file_handle)) {
3479                         /*
3480                          * This is actually for the QUOTA_FAKE_FILE --metze
3481                          */
3482
3483                         pstrcpy(fname, fsp->fsp_name);
3484                         /* We know this name is ok, it's already passed the checks. */
3485
3486                 } else if(fsp && (fsp->is_directory || fsp->fh->fd == -1)) {
3487                         /*
3488                          * This is actually a QFILEINFO on a directory
3489                          * handle (returned from an NT SMB). NT5.0 seems
3490                          * to do this call. JRA.
3491                          */
3492                         /* We know this name is ok, it's already passed the checks. */
3493                         pstrcpy(fname, fsp->fsp_name);
3494
3495                         if (INFO_LEVEL_IS_UNIX(info_level)) {
3496                                 /* Always do lstat for UNIX calls. */
3497                                 if (SMB_VFS_LSTAT(conn,fname,&sbuf)) {
3498                                         DEBUG(3,("call_trans2qfilepathinfo: SMB_VFS_LSTAT of %s failed (%s)\n",fname,strerror(errno)));
3499                                         reply_unixerror(req,ERRDOS,ERRbadpath);
3500                                         return;
3501                                 }
3502                         } else if (SMB_VFS_STAT(conn,fname,&sbuf)) {
3503                                 DEBUG(3,("call_trans2qfilepathinfo: SMB_VFS_STAT of %s failed (%s)\n",fname,strerror(errno)));
3504                                 reply_unixerror(req, ERRDOS, ERRbadpath);
3505                                 return;
3506                         }
3507
3508                         fileid = vfs_file_id_from_sbuf(conn, &sbuf);
3509                         delete_pending = get_delete_on_close_flag(fileid);
3510                 } else {
3511                         /*
3512                          * Original code - this is an open file.
3513                          */
3514                         if (!check_fsp(conn, req, fsp, &current_user)) {
3515                                 return;
3516                         }
3517
3518                         pstrcpy(fname, fsp->fsp_name);
3519                         if (SMB_VFS_FSTAT(fsp,fsp->fh->fd,&sbuf) != 0) {
3520                                 DEBUG(3,("fstat of fnum %d failed (%s)\n", fsp->fnum, strerror(errno)));
3521                                 reply_unixerror(req, ERRDOS, ERRbadfid);
3522                                 return;
3523                         }
3524                         pos = fsp->fh->position_information;
3525                         fileid = vfs_file_id_from_sbuf(conn, &sbuf);
3526                         delete_pending = get_delete_on_close_flag(fileid);
3527                         access_mask = fsp->access_mask;
3528                 }
3529         } else {
3530                 NTSTATUS status = NT_STATUS_OK;
3531
3532                 /* qpathinfo */
3533                 if (total_params < 7) {
3534                         reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
3535                         return;
3536                 }
3537
3538                 info_level = SVAL(params,0);
3539
3540                 DEBUG(3,("call_trans2qfilepathinfo: TRANSACT2_QPATHINFO: level = %d\n", info_level));
3541
3542                 if (INFO_LEVEL_IS_UNIX(info_level) && !lp_unix_extensions()) {
3543                         reply_nterror(req, NT_STATUS_INVALID_LEVEL);
3544                         return;
3545                 }
3546
3547                 srvstr_get_path(params, req->flags2, fname, &params[6],
3548                                 sizeof(fname), total_params - 6,
3549                                 STR_TERMINATE, &status);
3550                 if (!NT_STATUS_IS_OK(status)) {
3551                         reply_nterror(req, status);
3552                         return;
3553                 }
3554
3555                 status = resolve_dfspath(conn,
3556                                          req->flags2 & FLAGS2_DFS_PATHNAMES,
3557                                          fname);
3558                 if (!NT_STATUS_IS_OK(status)) {
3559                         if (NT_STATUS_EQUAL(status,NT_STATUS_PATH_NOT_COVERED)) {
3560                                 reply_botherror(req,
3561                                                 NT_STATUS_PATH_NOT_COVERED,
3562                                                 ERRSRV, ERRbadpath);
3563                         }
3564                         reply_nterror(req, status);
3565                         return;
3566                 }
3567
3568                 status = unix_convert(conn, fname, False, NULL, &sbuf);
3569                 if (!NT_STATUS_IS_OK(status)) {
3570                         reply_nterror(req, status);
3571                         return;
3572                 }
3573                 status = check_name(conn, fname);
3574                 if (!NT_STATUS_IS_OK(status)) {
3575                         DEBUG(3,("call_trans2qfilepathinfo: fileinfo of %s failed (%s)\n",fname,nt_errstr(status)));
3576                         reply_nterror(req, status);
3577                         return;
3578                 }
3579
3580                 if (INFO_LEVEL_IS_UNIX(info_level)) {
3581                         /* Always do lstat for UNIX calls. */
3582                         if (SMB_VFS_LSTAT(conn,fname,&sbuf)) {
3583                                 DEBUG(3,("call_trans2qfilepathinfo: SMB_VFS_LSTAT of %s failed (%s)\n",fname,strerror(errno)));
3584                                 reply_unixerror(req, ERRDOS, ERRbadpath);
3585                                 return;
3586                         }
3587                 } else if (!VALID_STAT(sbuf) && SMB_VFS_STAT(conn,fname,&sbuf) && (info_level != SMB_INFO_IS_NAME_VALID)) {
3588                         DEBUG(3,("call_trans2qfilepathinfo: SMB_VFS_STAT of %s failed (%s)\n",fname,strerror(errno)));
3589                         reply_unixerror(req, ERRDOS, ERRbadpath);
3590                         return;
3591                 }
3592
3593                 fileid = vfs_file_id_from_sbuf(conn, &sbuf);
3594                 delete_pending = get_delete_on_close_flag(fileid);
3595                 if (delete_pending) {
3596                         reply_nterror(req, NT_STATUS_DELETE_PENDING);
3597                         return;
3598                 }
3599         }
3600
3601         nlink = sbuf.st_nlink;
3602
3603         if ((nlink > 0) && S_ISDIR(sbuf.st_mode)) {
3604                 /* NTFS does not seem to count ".." */
3605                 nlink -= 1;
3606         }
3607
3608         if ((nlink > 0) && delete_pending) {
3609                 nlink -= 1;
3610         }
3611
3612         if (INFO_LEVEL_IS_UNIX(info_level) && !lp_unix_extensions()) {
3613                 reply_nterror(req, NT_STATUS_INVALID_LEVEL);
3614                 return;
3615         }
3616
3617         DEBUG(3,("call_trans2qfilepathinfo %s (fnum = %d) level=%d call=%d total_data=%d\n",
3618                 fname,fsp ? fsp->fnum : -1, info_level,tran_call,total_data));
3619
3620         p = strrchr_m(fname,'/');
3621         if (!p)
3622                 base_name = fname;
3623         else
3624                 base_name = p+1;
3625
3626         mode = dos_mode(conn,fname,&sbuf);
3627         if (!mode)
3628                 mode = FILE_ATTRIBUTE_NORMAL;
3629
3630         fullpathname = fname;
3631         if (!(mode & aDIR))
3632                 file_size = get_file_size(sbuf);
3633
3634         /* Pull out any data sent here before we realloc. */
3635         switch (info_level) {
3636                 case SMB_INFO_QUERY_EAS_FROM_LIST:
3637                 {
3638                         /* Pull any EA list from the data portion. */
3639                         uint32 ea_size;
3640
3641                         if (total_data < 4) {
3642                                 reply_nterror(
3643                                         req, NT_STATUS_INVALID_PARAMETER);
3644                                 return;
3645                         }
3646                         ea_size = IVAL(pdata,0);
3647
3648                         if (total_data > 0 && ea_size != total_data) {
3649                                 DEBUG(4,("call_trans2qfilepathinfo: Rejecting EA request with incorrect \
3650 total_data=%u (should be %u)\n", (unsigned int)total_data, (unsigned int)IVAL(pdata,0) ));
3651                                 reply_nterror(
3652                                         req, NT_STATUS_INVALID_PARAMETER);
3653                                 return;
3654                         }
3655
3656                         if (!lp_ea_support(SNUM(conn))) {
3657                                 reply_doserror(req, ERRDOS,
3658                                                ERReasnotsupported);
3659                                 return;
3660                         }
3661
3662                         if ((data_ctx = talloc_init("ea_list")) == NULL) {
3663                                 reply_nterror(req, NT_STATUS_NO_MEMORY);
3664                                 return;
3665                         }
3666
3667                         /* Pull out the list of names. */
3668                         ea_list = read_ea_name_list(data_ctx, pdata + 4, ea_size - 4);
3669                         if (!ea_list) {
3670                                 talloc_destroy(data_ctx);
3671                                 reply_nterror(
3672                                         req, NT_STATUS_INVALID_PARAMETER);
3673                                 return;
3674                         }
3675                         break;
3676                 }
3677
3678                 case SMB_QUERY_POSIX_LOCK:
3679                 {
3680                         if (fsp == NULL || fsp->fh->fd == -1) {
3681                                 reply_nterror(req, NT_STATUS_INVALID_HANDLE);
3682                                 return;
3683                         }
3684
3685                         if (total_data != POSIX_LOCK_DATA_SIZE) {
3686                                 reply_nterror(
3687                                         req, NT_STATUS_INVALID_PARAMETER);
3688                                 return;
3689                         }
3690
3691                         if ((data_ctx = talloc_init("lock_request")) == NULL) {
3692                                 reply_nterror(req, NT_STATUS_NO_MEMORY);
3693                                 return;
3694                         }
3695
3696                         /* Copy the lock range data. */
3697                         lock_data = (char *)TALLOC_MEMDUP(
3698                                 data_ctx, pdata, total_data);
3699                         if (!lock_data) {
3700                                 talloc_destroy(data_ctx);
3701                                 reply_nterror(req, NT_STATUS_NO_MEMORY);
3702                                 return;
3703                         }
3704                 }
3705                 default:
3706                         break;
3707         }
3708
3709         *pparams = (char *)SMB_REALLOC(*pparams,2);
3710         if (*pparams == NULL) {
3711                 talloc_destroy(data_ctx);
3712                 reply_nterror(req, NT_STATUS_NO_MEMORY);
3713                 return;
3714         }
3715         params = *pparams;
3716         SSVAL(params,0,0);
3717         data_size = max_data_bytes + DIR_ENTRY_SAFETY_MARGIN;
3718         *ppdata = (char *)SMB_REALLOC(*ppdata, data_size);
3719         if (*ppdata == NULL ) {
3720                 talloc_destroy(data_ctx);
3721                 reply_nterror(req, NT_STATUS_NO_MEMORY);
3722                 return;
3723         }
3724         pdata = *ppdata;
3725         dstart = pdata;
3726         dend = dstart + data_size - 1;
3727
3728         create_time_ts = get_create_timespec(&sbuf,lp_fake_dir_create_times(SNUM(conn)));
3729         mtime_ts = get_mtimespec(&sbuf);
3730         atime_ts = get_atimespec(&sbuf);
3731
3732         allocation_size = get_allocation_size(conn,fsp,&sbuf);
3733
3734         if (fsp) {
3735                 if (!null_timespec(fsp->pending_modtime)) {
3736                         /* the pending modtime overrides the current modtime */
3737                         mtime_ts = fsp->pending_modtime;
3738                 }
3739         } else {
3740                 files_struct *fsp1;
3741                 /* Do we have this path open ? */
3742                 fileid = vfs_file_id_from_sbuf(conn, &sbuf);
3743                 fsp1 = file_find_di_first(fileid);
3744                 if (fsp1 && !null_timespec(fsp1->pending_modtime)) {
3745                         /* the pending modtime overrides the current modtime */
3746                         mtime_ts = fsp1->pending_modtime;
3747                 }
3748                 if (fsp1 && fsp1->initial_allocation_size) {
3749                         allocation_size = get_allocation_size(conn, fsp1, &sbuf);
3750                 }
3751         }
3752
3753         if (lp_dos_filetime_resolution(SNUM(conn))) {
3754                 dos_filetime_timespec(&create_time_ts);
3755                 dos_filetime_timespec(&mtime_ts);
3756                 dos_filetime_timespec(&atime_ts);
3757         }
3758
3759         create_time = convert_timespec_to_time_t(create_time_ts);
3760         mtime = convert_timespec_to_time_t(mtime_ts);
3761         atime = convert_timespec_to_time_t(atime_ts);
3762
3763         /* NT expects the name to be in an exact form of the *full*
3764            filename. See the trans2 torture test */
3765         if (strequal(base_name,".")) {
3766                 pstrcpy(dos_fname, "\\");
3767         } else {
3768                 pstr_sprintf(dos_fname, "\\%s", fname);
3769                 string_replace(dos_fname, '/', '\\');
3770         }
3771
3772         switch (info_level) {
3773                 case SMB_INFO_STANDARD:
3774                         DEBUG(10,("call_trans2qfilepathinfo: SMB_INFO_STANDARD\n"));
3775                         data_size = 22;
3776                         srv_put_dos_date2(pdata,l1_fdateCreation,create_time);
3777                         srv_put_dos_date2(pdata,l1_fdateLastAccess,atime);
3778                         srv_put_dos_date2(pdata,l1_fdateLastWrite,mtime); /* write time */
3779                         SIVAL(pdata,l1_cbFile,(uint32)file_size);
3780                         SIVAL(pdata,l1_cbFileAlloc,(uint32)allocation_size);
3781                         SSVAL(pdata,l1_attrFile,mode);
3782                         break;
3783
3784                 case SMB_INFO_QUERY_EA_SIZE:
3785                 {
3786                         unsigned int ea_size = estimate_ea_size(conn, fsp, fname);
3787                         DEBUG(10,("call_trans2qfilepathinfo: SMB_INFO_QUERY_EA_SIZE\n"));
3788                         data_size = 26;
3789                         srv_put_dos_date2(pdata,0,create_time);
3790                         srv_put_dos_date2(pdata,4,atime);
3791                         srv_put_dos_date2(pdata,8,mtime); /* write time */
3792                         SIVAL(pdata,12,(uint32)file_size);
3793                         SIVAL(pdata,16,(uint32)allocation_size);
3794                         SSVAL(pdata,20,mode);
3795                         SIVAL(pdata,22,ea_size);
3796                         break;
3797                 }
3798
3799                 case SMB_INFO_IS_NAME_VALID:
3800                         DEBUG(10,("call_trans2qfilepathinfo: SMB_INFO_IS_NAME_VALID\n"));
3801                         if (tran_call == TRANSACT2_QFILEINFO) {
3802                                 /* os/2 needs this ? really ?*/
3803                                 reply_doserror(req, ERRDOS, ERRbadfunc);
3804                                 return;
3805                         }
3806                         data_size = 0;
3807                         param_size = 0;
3808                         break;
3809
3810                 case SMB_INFO_QUERY_EAS_FROM_LIST:
3811                 {
3812                         size_t total_ea_len = 0;
3813                         struct ea_list *ea_file_list = NULL;
3814
3815                         DEBUG(10,("call_trans2qfilepathinfo: SMB_INFO_QUERY_EAS_FROM_LIST\n"));
3816
3817                         ea_file_list = get_ea_list_from_file(data_ctx, conn, fsp, fname, &total_ea_len);
3818                         ea_list = ea_list_union(ea_list, ea_file_list, &total_ea_len);
3819
3820                         if (!ea_list || (total_ea_len > data_size)) {
3821                                 talloc_destroy(data_ctx);
3822                                 data_size = 4;
3823                                 SIVAL(pdata,0,4);   /* EA List Length must be set to 4 if no EA's. */
3824                                 break;
3825                         }
3826
3827                         data_size = fill_ea_buffer(data_ctx, pdata, data_size, conn, ea_list);
3828                         talloc_destroy(data_ctx);
3829                         break;
3830                 }
3831
3832                 case SMB_INFO_QUERY_ALL_EAS:
3833                 {
3834                         /* We have data_size bytes to put EA's into. */
3835                         size_t total_ea_len = 0;
3836
3837                         DEBUG(10,("call_trans2qfilepathinfo: SMB_INFO_QUERY_ALL_EAS\n"));
3838
3839                         data_ctx = talloc_init("ea_ctx");
3840                         if (!data_ctx) {
3841                                 reply_nterror(req, NT_STATUS_NO_MEMORY);
3842                                 return;
3843                         }
3844
3845                         ea_list = get_ea_list_from_file(data_ctx, conn, fsp, fname, &total_ea_len);
3846                         if (!ea_list || (total_ea_len > data_size)) {
3847                                 talloc_destroy(data_ctx);
3848                                 data_size = 4;
3849                                 SIVAL(pdata,0,4);   /* EA List Length must be set to 4 if no EA's. */
3850                                 break;
3851                         }
3852
3853                         data_size = fill_ea_buffer(data_ctx, pdata, data_size, conn, ea_list);
3854                         talloc_destroy(data_ctx);
3855                         break;
3856                 }
3857
3858                 case SMB_FILE_BASIC_INFORMATION:
3859                 case SMB_QUERY_FILE_BASIC_INFO:
3860
3861                         if (info_level == SMB_QUERY_FILE_BASIC_INFO) {
3862                                 DEBUG(10,("call_trans2qfilepathinfo: SMB_QUERY_FILE_BASIC_INFO\n"));
3863                                 data_size = 36; /* w95 returns 40 bytes not 36 - why ?. */
3864                         } else {
3865                                 DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_BASIC_INFORMATION\n"));
3866                                 data_size = 40;
3867                                 SIVAL(pdata,36,0);
3868                         }
3869                         put_long_date_timespec(pdata,create_time_ts);
3870                         put_long_date_timespec(pdata+8,atime_ts);
3871                         put_long_date_timespec(pdata+16,mtime_ts); /* write time */
3872                         put_long_date_timespec(pdata+24,mtime_ts); /* change time */
3873                         SIVAL(pdata,32,mode);
3874
3875                         DEBUG(5,("SMB_QFBI - "));
3876                         DEBUG(5,("create: %s ", ctime(&create_time)));
3877                         DEBUG(5,("access: %s ", ctime(&atime)));
3878                         DEBUG(5,("write: %s ", ctime(&mtime)));
3879                         DEBUG(5,("change: %s ", ctime(&mtime)));
3880                         DEBUG(5,("mode: %x\n", mode));
3881                         break;
3882
3883                 case SMB_FILE_STANDARD_INFORMATION:
3884                 case SMB_QUERY_FILE_STANDARD_INFO:
3885
3886                         DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_STANDARD_INFORMATION\n"));
3887                         data_size = 24;
3888                         SOFF_T(pdata,0,allocation_size);
3889                         SOFF_T(pdata,8,file_size);
3890                         SIVAL(pdata,16,nlink);
3891                         SCVAL(pdata,20,delete_pending?1:0);
3892                         SCVAL(pdata,21,(mode&aDIR)?1:0);
3893                         SSVAL(pdata,22,0); /* Padding. */
3894                         break;
3895
3896                 case SMB_FILE_EA_INFORMATION:
3897                 case SMB_QUERY_FILE_EA_INFO:
3898                 {
3899                         unsigned int ea_size = estimate_ea_size(conn, fsp, fname);
3900                         DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_EA_INFORMATION\n"));
3901                         data_size = 4;
3902                         SIVAL(pdata,0,ea_size);
3903                         break;
3904                 }
3905
3906                 /* Get the 8.3 name - used if NT SMB was negotiated. */
3907                 case SMB_QUERY_FILE_ALT_NAME_INFO:
3908                 case SMB_FILE_ALTERNATE_NAME_INFORMATION:
3909                 {
3910                         pstring short_name;
3911
3912                         DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_ALTERNATE_NAME_INFORMATION\n"));
3913                         pstrcpy(short_name,base_name);
3914                         /* Mangle if not already 8.3 */
3915                         if(!mangle_is_8_3(short_name, True, conn->params)) {
3916                                 mangle_map(short_name,True,True,conn->params);
3917                         }
3918                         len = srvstr_push(dstart, req->flags2,
3919                                           pdata+4, short_name,
3920                                           PTR_DIFF(dend, pdata+4),
3921                                           STR_UNICODE);
3922                         data_size = 4 + len;
3923                         SIVAL(pdata,0,len);
3924                         break;
3925                 }
3926
3927                 case SMB_QUERY_FILE_NAME_INFO:
3928                         /*
3929                           this must be *exactly* right for ACLs on mapped drives to work
3930                          */
3931                         len = srvstr_push(dstart, req->flags2,
3932                                           pdata+4, dos_fname,
3933                                           PTR_DIFF(dend, pdata+4),
3934                                           STR_UNICODE);
3935                         DEBUG(10,("call_trans2qfilepathinfo: SMB_QUERY_FILE_NAME_INFO\n"));
3936                         data_size = 4 + len;
3937                         SIVAL(pdata,0,len);
3938                         break;
3939
3940                 case SMB_FILE_ALLOCATION_INFORMATION:
3941                 case SMB_QUERY_FILE_ALLOCATION_INFO:
3942                         DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_ALLOCATION_INFORMATION\n"));
3943                         data_size = 8;
3944                         SOFF_T(pdata,0,allocation_size);
3945                         break;
3946
3947                 case SMB_FILE_END_OF_FILE_INFORMATION:
3948                 case SMB_QUERY_FILE_END_OF_FILEINFO:
3949                         DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_END_OF_FILE_INFORMATION\n"));
3950                         data_size = 8;
3951                         SOFF_T(pdata,0,file_size);
3952                         break;
3953
3954                 case SMB_QUERY_FILE_ALL_INFO:
3955                 case SMB_FILE_ALL_INFORMATION:
3956                 {
3957                         unsigned int ea_size = estimate_ea_size(conn, fsp, fname);
3958                         DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_ALL_INFORMATION\n"));
3959                         put_long_date_timespec(pdata,create_time_ts);
3960                         put_long_date_timespec(pdata+8,atime_ts);
3961                         put_long_date_timespec(pdata+16,mtime_ts); /* write time */
3962                         put_long_date_timespec(pdata+24,mtime_ts); /* change time */
3963                         SIVAL(pdata,32,mode);
3964                         SIVAL(pdata,36,0); /* padding. */
3965                         pdata += 40;
3966                         SOFF_T(pdata,0,allocation_size);
3967                         SOFF_T(pdata,8,file_size);
3968                         SIVAL(pdata,16,nlink);
3969                         SCVAL(pdata,20,delete_pending);
3970                         SCVAL(pdata,21,(mode&aDIR)?1:0);
3971                         SSVAL(pdata,22,0);
3972                         pdata += 24;
3973                         SIVAL(pdata,0,ea_size);
3974                         pdata += 4; /* EA info */
3975                         len = srvstr_push(dstart, req->flags2,
3976                                           pdata+4, dos_fname,
3977                                           PTR_DIFF(dend, pdata+4),
3978                                           STR_UNICODE);
3979                         SIVAL(pdata,0,len);
3980                         pdata += 4 + len;
3981                         data_size = PTR_DIFF(pdata,(*ppdata));
3982                         break;
3983                 }
3984                 case SMB_FILE_INTERNAL_INFORMATION:
3985                         /* This should be an index number - looks like
3986                            dev/ino to me :-)
3987
3988                            I think this causes us to fail the IFSKIT
3989                            BasicFileInformationTest. -tpot */
3990
3991                         DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_INTERNAL_INFORMATION\n"));
3992                         SIVAL(pdata,0,sbuf.st_ino); /* FileIndexLow */
3993                         SIVAL(pdata,4,sbuf.st_dev); /* FileIndexHigh */
3994                         data_size = 8;
3995                         break;
3996
3997                 case SMB_FILE_ACCESS_INFORMATION:
3998                         DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_ACCESS_INFORMATION\n"));
3999                         SIVAL(pdata,0,access_mask);
4000                         data_size = 4;
4001                         break;
4002
4003                 case SMB_FILE_NAME_INFORMATION:
4004                         /* Pathname with leading '\'. */
4005                         {
4006                                 size_t byte_len;
4007                                 byte_len = dos_PutUniCode(pdata+4,dos_fname,(size_t)max_data_bytes,False);
4008                                 DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_NAME_INFORMATION\n"));
4009                                 SIVAL(pdata,0,byte_len);
4010                                 data_size = 4 + byte_len;
4011                                 break;
4012                         }
4013
4014                 case SMB_FILE_DISPOSITION_INFORMATION:
4015                         DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_DISPOSITION_INFORMATION\n"));
4016                         data_size = 1;
4017                         SCVAL(pdata,0,delete_pending);
4018                         break;
4019
4020                 case SMB_FILE_POSITION_INFORMATION:
4021                         DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_POSITION_INFORMATION\n"));
4022                         data_size = 8;
4023                         SOFF_T(pdata,0,pos);
4024                         break;
4025
4026                 case SMB_FILE_MODE_INFORMATION:
4027                         DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_MODE_INFORMATION\n"));
4028                         SIVAL(pdata,0,mode);
4029                         data_size = 4;
4030                         break;
4031
4032                 case SMB_FILE_ALIGNMENT_INFORMATION:
4033                         DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_ALIGNMENT_INFORMATION\n"));
4034                         SIVAL(pdata,0,0); /* No alignment needed. */
4035                         data_size = 4;
4036                         break;
4037
4038 #if 0
4039                 /*
4040                  * NT4 server just returns "invalid query" to this - if we try to answer
4041                  * it then NTws gets a BSOD! (tridge).
4042                  * W2K seems to want this. JRA.
4043                  */
4044                 case SMB_QUERY_FILE_STREAM_INFO:
4045 #endif
4046                 case SMB_FILE_STREAM_INFORMATION:
4047                         DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_STREAM_INFORMATION\n"));
4048                         if (mode & aDIR) {
4049                                 data_size = 0;
4050                         } else {
4051                                 size_t byte_len = dos_PutUniCode(pdata+24,"::$DATA", (size_t)0xE, False);
4052                                 SIVAL(pdata,0,0); /* ??? */
4053                                 SIVAL(pdata,4,byte_len); /* Byte length of unicode string ::$DATA */
4054                                 SOFF_T(pdata,8,file_size);
4055                                 SOFF_T(pdata,16,allocation_size);
4056                                 data_size = 24 + byte_len;
4057                         }
4058                         break;
4059
4060                 case SMB_QUERY_COMPRESSION_INFO:
4061                 case SMB_FILE_COMPRESSION_INFORMATION:
4062                         DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_COMPRESSION_INFORMATION\n"));
4063                         SOFF_T(pdata,0,file_size);
4064                         SIVAL(pdata,8,0); /* ??? */
4065                         SIVAL(pdata,12,0); /* ??? */
4066                         data_size = 16;
4067                         break;
4068
4069                 case SMB_FILE_NETWORK_OPEN_INFORMATION:
4070                         DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_NETWORK_OPEN_INFORMATION\n"));
4071                         put_long_date_timespec(pdata,create_time_ts);
4072                         put_long_date_timespec(pdata+8,atime_ts);
4073                         put_long_date_timespec(pdata+16,mtime_ts); /* write time */
4074                         put_long_date_timespec(pdata+24,mtime_ts); /* change time */
4075                         SOFF_T(pdata,32,allocation_size);
4076                         SOFF_T(pdata,40,file_size);
4077                         SIVAL(pdata,48,mode);
4078                         SIVAL(pdata,52,0); /* ??? */
4079                         data_size = 56;
4080                         break;
4081
4082                 case SMB_FILE_ATTRIBUTE_TAG_INFORMATION:
4083                         DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_ATTRIBUTE_TAG_INFORMATION\n"));
4084                         SIVAL(pdata,0,mode);
4085                         SIVAL(pdata,4,0);
4086                         data_size = 8;
4087                         break;
4088
4089                 /*
4090                  * CIFS UNIX Extensions.
4091                  */
4092
4093                 case SMB_QUERY_FILE_UNIX_BASIC:
4094
4095                         pdata = store_file_unix_basic(conn, pdata, fsp, &sbuf);
4096                         data_size = PTR_DIFF(pdata,(*ppdata));
4097
4098                         {
4099                                 int i;
4100                                 DEBUG(4,("call_trans2qfilepathinfo: SMB_QUERY_FILE_UNIX_BASIC "));
4101
4102                                 for (i=0; i<100; i++)
4103                                         DEBUG(4,("%d=%x, ",i, (*ppdata)[i]));
4104                                 DEBUG(4,("\n"));
4105                         }
4106
4107                         break;
4108
4109                 case SMB_QUERY_FILE_UNIX_INFO2:
4110
4111                         pdata = store_file_unix_basic_info2(conn, pdata, fsp, &sbuf);
4112                         data_size = PTR_DIFF(pdata,(*ppdata));
4113
4114                         {
4115                                 int i;
4116                                 DEBUG(4,("call_trans2qfilepathinfo: SMB_QUERY_FILE_UNIX_INFO2 "));
4117
4118                                 for (i=0; i<100; i++)
4119                                         DEBUG(4,("%d=%x, ",i, (*ppdata)[i]));
4120                                 DEBUG(4,("\n"));
4121                         }
4122
4123                         break;
4124
4125                 case SMB_QUERY_FILE_UNIX_LINK:
4126                         {
4127                                 pstring buffer;
4128
4129                                 DEBUG(10,("call_trans2qfilepathinfo: SMB_QUERY_FILE_UNIX_LINK\n"));
4130 #ifdef S_ISLNK
4131                                 if(!S_ISLNK(sbuf.st_mode)) {
4132                                         reply_unixerror(req, ERRSRV,
4133                                                         ERRbadlink);
4134                                         return;
4135                                 }
4136 #else
4137                                 reply_unixerror(req, ERRDOS, ERRbadlink);
4138                                 return;
4139 #endif
4140                                 len = SMB_VFS_READLINK(conn,fullpathname, buffer, sizeof(pstring)-1);     /* read link */
4141                                 if (len == -1) {
4142                                         reply_unixerror(req, ERRDOS,
4143                                                         ERRnoaccess);
4144                                         return;
4145                                 }
4146                                 buffer[len] = 0;
4147                                 len = srvstr_push(dstart, req->flags2,
4148                                                   pdata, buffer,
4149                                                   PTR_DIFF(dend, pdata),
4150                                                   STR_TERMINATE);
4151                                 pdata += len;
4152                                 data_size = PTR_DIFF(pdata,(*ppdata));
4153
4154                                 break;
4155                         }
4156
4157 #if defined(HAVE_POSIX_ACLS)
4158                 case SMB_QUERY_POSIX_ACL:
4159                         {
4160                                 SMB_ACL_T file_acl = NULL;
4161                                 SMB_ACL_T def_acl = NULL;
4162                                 uint16 num_file_acls = 0;
4163                                 uint16 num_def_acls = 0;
4164
4165                                 if (fsp && !fsp->is_directory && (fsp->fh->fd != -1)) {
4166                                         file_acl = SMB_VFS_SYS_ACL_GET_FD(fsp, fsp->fh->fd);
4167                                 } else {
4168                                         file_acl = SMB_VFS_SYS_ACL_GET_FILE(conn, fname, SMB_ACL_TYPE_ACCESS);
4169                                 }
4170
4171                                 if (file_acl == NULL && no_acl_syscall_error(errno)) {
4172                                         DEBUG(5,("call_trans2qfilepathinfo: ACLs not implemented on filesystem containing %s\n",
4173                                                 fname ));
4174                                         reply_nterror(
4175                                                 req,
4176                                                 NT_STATUS_NOT_IMPLEMENTED);
4177                                         return;
4178                                 }
4179
4180                                 if (S_ISDIR(sbuf.st_mode)) {
4181                                         if (fsp && fsp->is_directory) {
4182                                                 def_acl = SMB_VFS_SYS_ACL_GET_FILE(conn, fsp->fsp_name, SMB_ACL_TYPE_DEFAULT);
4183                                         } else {
4184                                                 def_acl = SMB_VFS_SYS_ACL_GET_FILE(conn, fname, SMB_ACL_TYPE_DEFAULT);
4185                                         }
4186                                         def_acl = free_empty_sys_acl(conn, def_acl);
4187                                 }
4188
4189                                 num_file_acls = count_acl_entries(conn, file_acl);
4190                                 num_def_acls = count_acl_entries(conn, def_acl);
4191
4192                                 if ( data_size < (num_file_acls + num_def_acls)*SMB_POSIX_ACL_ENTRY_SIZE + SMB_POSIX_ACL_HEADER_SIZE) {
4193                                         DEBUG(5,("call_trans2qfilepathinfo: data_size too small (%u) need %u\n",
4194                                                 data_size,
4195                                                 (unsigned int)((num_file_acls + num_def_acls)*SMB_POSIX_ACL_ENTRY_SIZE +
4196                                                         SMB_POSIX_ACL_HEADER_SIZE) ));
4197                                         if (file_acl) {
4198                                                 SMB_VFS_SYS_ACL_FREE_ACL(conn, file_acl);
4199                                         }
4200                                         if (def_acl) {
4201                                                 SMB_VFS_SYS_ACL_FREE_ACL(conn, def_acl);
4202                                         }
4203                                         reply_nterror(
4204                                                 req,
4205                                                 NT_STATUS_BUFFER_TOO_SMALL);
4206                                         return;
4207                                 }
4208
4209                                 SSVAL(pdata,0,SMB_POSIX_ACL_VERSION);
4210                                 SSVAL(pdata,2,num_file_acls);
4211                                 SSVAL(pdata,4,num_def_acls);
4212                                 if (!marshall_posix_acl(conn, pdata + SMB_POSIX_ACL_HEADER_SIZE, &sbuf, file_acl)) {
4213                                         if (file_acl) {
4214                                                 SMB_VFS_SYS_ACL_FREE_ACL(conn, file_acl);
4215                                         }
4216                                         if (def_acl) {
4217                                                 SMB_VFS_SYS_ACL_FREE_ACL(conn, def_acl);
4218                                         }
4219                                         reply_nterror(
4220                                                 req, NT_STATUS_INTERNAL_ERROR);
4221                                         return;
4222                                 }
4223                                 if (!marshall_posix_acl(conn, pdata + SMB_POSIX_ACL_HEADER_SIZE + (num_file_acls*SMB_POSIX_ACL_ENTRY_SIZE), &sbuf, def_acl)) {
4224                                         if (file_acl) {
4225                                                 SMB_VFS_SYS_ACL_FREE_ACL(conn, file_acl);
4226                                         }
4227                                         if (def_acl) {
4228                                                 SMB_VFS_SYS_ACL_FREE_ACL(conn, def_acl);
4229                                         }
4230                                         reply_nterror(
4231                                                 req,
4232                                                 NT_STATUS_INTERNAL_ERROR);
4233                                         return;
4234                                 }
4235
4236                                 if (file_acl) {
4237                                         SMB_VFS_SYS_ACL_FREE_ACL(conn, file_acl);
4238                                 }
4239                                 if (def_acl) {
4240                                         SMB_VFS_SYS_ACL_FREE_ACL(conn, def_acl);
4241                                 }
4242                                 data_size = (num_file_acls + num_def_acls)*SMB_POSIX_ACL_ENTRY_SIZE + SMB_POSIX_ACL_HEADER_SIZE;
4243                                 break;
4244                         }
4245 #endif
4246
4247
4248                 case SMB_QUERY_POSIX_LOCK:
4249                 {
4250                         NTSTATUS status = NT_STATUS_INVALID_LEVEL;
4251                         SMB_BIG_UINT count;
4252                         SMB_BIG_UINT offset;
4253                         uint32 lock_pid;
4254                         enum brl_type lock_type;
4255
4256                         if (total_data != POSIX_LOCK_DATA_SIZE) {
4257                                 reply_nterror(
4258                                         req, NT_STATUS_INVALID_PARAMETER);
4259                                 return;
4260                         }
4261
4262                         switch (SVAL(pdata, POSIX_LOCK_TYPE_OFFSET)) {
4263                                 case POSIX_LOCK_TYPE_READ:
4264                                         lock_type = READ_LOCK;
4265                                         break;
4266                                 case POSIX_LOCK_TYPE_WRITE:
4267                                         lock_type = WRITE_LOCK;
4268                                         break;
4269                                 case POSIX_LOCK_TYPE_UNLOCK:
4270                                 default:
4271                                         /* There's no point in asking for an unlock... */
4272                                         talloc_destroy(data_ctx);
4273                                         reply_nterror(
4274                                                 req,
4275                                                 NT_STATUS_INVALID_PARAMETER);
4276                                         return;
4277                         }
4278
4279                         lock_pid = IVAL(pdata, POSIX_LOCK_PID_OFFSET);
4280 #if defined(HAVE_LONGLONG)
4281                         offset = (((SMB_BIG_UINT) IVAL(pdata,(POSIX_LOCK_START_OFFSET+4))) << 32) |
4282                                         ((SMB_BIG_UINT) IVAL(pdata,POSIX_LOCK_START_OFFSET));
4283                         count = (((SMB_BIG_UINT) IVAL(pdata,(POSIX_LOCK_LEN_OFFSET+4))) << 32) |
4284                                         ((SMB_BIG_UINT) IVAL(pdata,POSIX_LOCK_LEN_OFFSET));
4285 #else /* HAVE_LONGLONG */
4286                         offset = (SMB_BIG_UINT)IVAL(pdata,POSIX_LOCK_START_OFFSET);
4287                         count = (SMB_BIG_UINT)IVAL(pdata,POSIX_LOCK_LEN_OFFSET);
4288 #endif /* HAVE_LONGLONG */
4289
4290                         status = query_lock(fsp,
4291                                         &lock_pid,
4292                                         &count,
4293                                         &offset,
4294                                         &lock_type,
4295                                         POSIX_LOCK);
4296
4297                         if (ERROR_WAS_LOCK_DENIED(status)) {
4298                                 /* Here we need to report who has it locked... */
4299                                 data_size = POSIX_LOCK_DATA_SIZE;
4300
4301                                 SSVAL(pdata, POSIX_LOCK_TYPE_OFFSET, lock_type);
4302                                 SSVAL(pdata, POSIX_LOCK_FLAGS_OFFSET, 0);
4303                                 SIVAL(pdata, POSIX_LOCK_PID_OFFSET, lock_pid);
4304 #if defined(HAVE_LONGLONG)
4305                                 SIVAL(pdata, POSIX_LOCK_START_OFFSET, (uint32)(offset & 0xFFFFFFFF));
4306                                 SIVAL(pdata, POSIX_LOCK_START_OFFSET + 4, (uint32)((offset >> 32) & 0xFFFFFFFF));
4307                                 SIVAL(pdata, POSIX_LOCK_LEN_OFFSET, (uint32)(count & 0xFFFFFFFF));
4308                                 SIVAL(pdata, POSIX_LOCK_LEN_OFFSET + 4, (uint32)((count >> 32) & 0xFFFFFFFF));
4309 #else /* HAVE_LONGLONG */
4310                                 SIVAL(pdata, POSIX_LOCK_START_OFFSET, offset);
4311                                 SIVAL(pdata, POSIX_LOCK_LEN_OFFSET, count);
4312 #endif /* HAVE_LONGLONG */
4313
4314                         } else if (NT_STATUS_IS_OK(status)) {
4315                                 /* For success we just return a copy of what we sent
4316                                    with the lock type set to POSIX_LOCK_TYPE_UNLOCK. */
4317                                 data_size = POSIX_LOCK_DATA_SIZE;
4318                                 memcpy(pdata, lock_data, POSIX_LOCK_DATA_SIZE);
4319                                 SSVAL(pdata, POSIX_LOCK_TYPE_OFFSET, POSIX_LOCK_TYPE_UNLOCK);
4320                         } else {
4321                                 reply_nterror(req, status);
4322                                 return;
4323                         }
4324                         break;
4325                 }
4326
4327                 default:
4328                         reply_nterror(req, NT_STATUS_INVALID_LEVEL);
4329                         return;
4330         }
4331
4332         send_trans2_replies_new(req, params, param_size, *ppdata, data_size,
4333                                 max_data_bytes);
4334
4335         return;
4336 }
4337
4338 /****************************************************************************
4339  Set a hard link (called by UNIX extensions and by NT rename with HARD link
4340  code.
4341 ****************************************************************************/
4342
4343 NTSTATUS hardlink_internals(connection_struct *conn, pstring oldname, pstring newname)
4344 {
4345         SMB_STRUCT_STAT sbuf1, sbuf2;
4346         pstring last_component_oldname;
4347         pstring last_component_newname;
4348         NTSTATUS status = NT_STATUS_OK;
4349
4350         ZERO_STRUCT(sbuf1);
4351         ZERO_STRUCT(sbuf2);
4352
4353         status = unix_convert(conn, oldname, False, last_component_oldname, &sbuf1);
4354         if (!NT_STATUS_IS_OK(status)) {
4355                 return status;
4356         }
4357
4358         status = check_name(conn, oldname);
4359         if (!NT_STATUS_IS_OK(status)) {
4360                 return status;
4361         }
4362
4363         /* source must already exist. */
4364         if (!VALID_STAT(sbuf1)) {
4365                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
4366         }
4367
4368         status = unix_convert(conn, newname, False, last_component_newname, &sbuf2);
4369         if (!NT_STATUS_IS_OK(status)) {
4370                 return status;
4371         }
4372
4373         status = check_name(conn, newname);
4374         if (!NT_STATUS_IS_OK(status)) {
4375                 return status;
4376         }
4377
4378         /* Disallow if newname already exists. */
4379         if (VALID_STAT(sbuf2)) {
4380                 return NT_STATUS_OBJECT_NAME_COLLISION;
4381         }
4382
4383         /* No links from a directory. */
4384         if (S_ISDIR(sbuf1.st_mode)) {
4385                 return NT_STATUS_FILE_IS_A_DIRECTORY;
4386         }
4387
4388         /* Ensure this is within the share. */
4389         status = check_reduced_name(conn, oldname);
4390         if (!NT_STATUS_IS_OK(status)) {
4391                 return status;
4392         }
4393
4394         DEBUG(10,("hardlink_internals: doing hard link %s -> %s\n", newname, oldname ));
4395
4396         if (SMB_VFS_LINK(conn,oldname,newname) != 0) {
4397                 status = map_nt_error_from_unix(errno);
4398                 DEBUG(3,("hardlink_internals: Error %s hard link %s -> %s\n",
4399                                 nt_errstr(status), newname, oldname));
4400         }
4401
4402         return status;
4403 }
4404
4405 /****************************************************************************
4406  Deal with setting the time from any of the setfilepathinfo functions.
4407 ****************************************************************************/
4408
4409 static NTSTATUS smb_set_file_time(connection_struct *conn,
4410                                 files_struct *fsp,
4411                                 const char *fname,
4412                                 const SMB_STRUCT_STAT *psbuf,
4413                                 struct timespec ts[2])
4414 {
4415         uint32 action =
4416                 FILE_NOTIFY_CHANGE_LAST_ACCESS
4417                 |FILE_NOTIFY_CHANGE_LAST_WRITE;
4418
4419
4420         if (!VALID_STAT(*psbuf)) {
4421                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
4422         }
4423
4424         /* get some defaults (no modifications) if any info is zero or -1. */
4425         if (null_timespec(ts[0])) {
4426                 ts[0] = get_atimespec(psbuf);
4427                 action &= ~FILE_NOTIFY_CHANGE_LAST_ACCESS;
4428         }
4429
4430         if (null_timespec(ts[1])) {
4431                 ts[1] = get_mtimespec(psbuf);
4432                 action &= ~FILE_NOTIFY_CHANGE_LAST_WRITE;
4433         }
4434
4435         DEBUG(6,("smb_set_file_time: actime: %s " , time_to_asc(convert_timespec_to_time_t(ts[0])) ));
4436         DEBUG(6,("smb_set_file_time: modtime: %s ", time_to_asc(convert_timespec_to_time_t(ts[1])) ));
4437
4438         /*
4439          * Try and set the times of this file if
4440          * they are different from the current values.
4441          */
4442
4443         {
4444                 struct timespec mts = get_mtimespec(psbuf);
4445                 struct timespec ats = get_atimespec(psbuf);
4446                 if ((timespec_compare(&ts[0], &ats) == 0) && (timespec_compare(&ts[1], &mts) == 0)) {
4447                         return NT_STATUS_OK;
4448                 }
4449         }
4450
4451         if(fsp != NULL) {
4452                 /*
4453                  * This was a setfileinfo on an open file.
4454                  * NT does this a lot. We also need to
4455                  * set the time here, as it can be read by
4456                  * FindFirst/FindNext and with the patch for bug #2045
4457                  * in smbd/fileio.c it ensures that this timestamp is
4458                  * kept sticky even after a write. We save the request
4459                  * away and will set it on file close and after a write. JRA.
4460                  */
4461
4462                 if (!null_timespec(ts[1])) {
4463                         DEBUG(10,("smb_set_file_time: setting pending modtime to %s\n",
4464                                 time_to_asc(convert_timespec_to_time_t(ts[1])) ));
4465                         fsp_set_pending_modtime(fsp, ts[1]);
4466                 }
4467
4468         }
4469         DEBUG(10,("smb_set_file_time: setting utimes to modified values.\n"));
4470
4471         if(file_ntimes(conn, fname, ts)!=0) {
4472                 return map_nt_error_from_unix(errno);
4473         }
4474         if (action != 0) {
4475                 notify_fname(conn, NOTIFY_ACTION_MODIFIED, action, fname);
4476         }
4477         return NT_STATUS_OK;
4478 }
4479
4480 /****************************************************************************
4481  Deal with setting the dosmode from any of the setfilepathinfo functions.
4482 ****************************************************************************/
4483
4484 static NTSTATUS smb_set_file_dosmode(connection_struct *conn,
4485                                 const char *fname,
4486                                 SMB_STRUCT_STAT *psbuf,
4487                                 uint32 dosmode)
4488 {
4489         if (!VALID_STAT(*psbuf)) {
4490                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
4491         }
4492
4493         if (dosmode) {
4494                 if (S_ISDIR(psbuf->st_mode)) {
4495                         dosmode |= aDIR;
4496                 } else {
4497                         dosmode &= ~aDIR;
4498                 }
4499         }
4500
4501         DEBUG(6,("smb_set_file_dosmode: dosmode: 0x%x\n", (unsigned int)dosmode));
4502
4503         /* check the mode isn't different, before changing it */
4504         if ((dosmode != 0) && (dosmode != dos_mode(conn, fname, psbuf))) {
4505
4506                 DEBUG(10,("smb_set_file_dosmode: file %s : setting dos mode 0x%x\n",
4507                                         fname, (unsigned int)dosmode ));
4508
4509                 if(file_set_dosmode(conn, fname, dosmode, psbuf, False)) {
4510                         DEBUG(2,("smb_set_file_dosmode: file_set_dosmode of %s failed (%s)\n",
4511                                                 fname, strerror(errno)));
4512                         return map_nt_error_from_unix(errno);
4513                 }
4514         }
4515         return NT_STATUS_OK;
4516 }
4517
4518 /****************************************************************************
4519  Deal with setting the size from any of the setfilepathinfo functions.
4520 ****************************************************************************/
4521
4522 static NTSTATUS smb_set_file_size(connection_struct *conn,
4523                                   struct smb_request *req,
4524                                 files_struct *fsp,
4525                                 const char *fname,
4526                                 SMB_STRUCT_STAT *psbuf,
4527                                 SMB_OFF_T size)
4528 {
4529         NTSTATUS status = NT_STATUS_OK;
4530         files_struct *new_fsp = NULL;
4531
4532         if (!VALID_STAT(*psbuf)) {
4533                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
4534         }
4535
4536         DEBUG(6,("smb_set_file_size: size: %.0f ", (double)size));
4537
4538         if (size == get_file_size(*psbuf)) {
4539                 return NT_STATUS_OK;
4540         }
4541
4542         DEBUG(10,("smb_set_file_size: file %s : setting new size to %.0f\n",
4543                 fname, (double)size ));
4544
4545         if (fsp && fsp->fh->fd != -1) {
4546                 /* Handle based call. */
4547                 if (vfs_set_filelen(fsp, size) == -1) {
4548                         return map_nt_error_from_unix(errno);
4549                 }
4550                 return NT_STATUS_OK;
4551         }
4552
4553         status = open_file_ntcreate(conn, req, fname, psbuf,
4554                                 FILE_WRITE_DATA,
4555                                 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
4556                                 FILE_OPEN,
4557                                 0,
4558                                 FILE_ATTRIBUTE_NORMAL,
4559                                 FORCE_OPLOCK_BREAK_TO_NONE,
4560                                 NULL, &new_fsp);
4561
4562         if (!NT_STATUS_IS_OK(status)) {
4563                 /* NB. We check for open_was_deferred in the caller. */
4564                 return status;
4565         }
4566
4567         if (vfs_set_filelen(new_fsp, size) == -1) {
4568                 status = map_nt_error_from_unix(errno);
4569                 close_file(new_fsp,NORMAL_CLOSE);
4570                 return status;
4571         }
4572
4573         close_file(new_fsp,NORMAL_CLOSE);
4574         return NT_STATUS_OK;
4575 }
4576
4577 /****************************************************************************
4578  Deal with SMB_INFO_SET_EA.
4579 ****************************************************************************/
4580
4581 static NTSTATUS smb_info_set_ea(connection_struct *conn,
4582                                 const char *pdata,
4583                                 int total_data,
4584                                 files_struct *fsp,
4585                                 const char *fname)
4586 {
4587         struct ea_list *ea_list = NULL;
4588         TALLOC_CTX *ctx = NULL;
4589         NTSTATUS status = NT_STATUS_OK;
4590
4591         if (total_data < 10) {
4592
4593                 /* OS/2 workplace shell seems to send SET_EA requests of "null"
4594                    length. They seem to have no effect. Bug #3212. JRA */
4595
4596                 if ((total_data == 4) && (IVAL(pdata,0) == 4)) {
4597                         /* We're done. We only get EA info in this call. */
4598                         return NT_STATUS_OK;
4599                 }
4600
4601                 return NT_STATUS_INVALID_PARAMETER;
4602         }
4603
4604         if (IVAL(pdata,0) > total_data) {
4605                 DEBUG(10,("smb_info_set_ea: bad total data size (%u) > %u\n",
4606                         IVAL(pdata,0), (unsigned int)total_data));
4607                 return NT_STATUS_INVALID_PARAMETER;
4608         }
4609
4610         ctx = talloc_init("SMB_INFO_SET_EA");
4611         if (!ctx) {
4612                 return NT_STATUS_NO_MEMORY;
4613         }
4614         ea_list = read_ea_list(ctx, pdata + 4, total_data - 4);
4615         if (!ea_list) {
4616                 talloc_destroy(ctx);
4617                 return NT_STATUS_INVALID_PARAMETER;
4618         }
4619         status = set_ea(conn, fsp, fname, ea_list);
4620         talloc_destroy(ctx);
4621
4622         return status;
4623 }
4624
4625 /****************************************************************************
4626  Deal with SMB_SET_FILE_DISPOSITION_INFO.
4627 ****************************************************************************/
4628
4629 static NTSTATUS smb_set_file_disposition_info(connection_struct *conn,
4630                                 const char *pdata,
4631                                 int total_data,
4632                                 files_struct *fsp,
4633                                 const char *fname,
4634                                 SMB_STRUCT_STAT *psbuf)
4635 {
4636         NTSTATUS status = NT_STATUS_OK;
4637         BOOL delete_on_close;
4638         uint32 dosmode = 0;
4639
4640         if (total_data < 1) {
4641                 return NT_STATUS_INVALID_PARAMETER;
4642         }
4643
4644         if (fsp == NULL) {
4645                 return NT_STATUS_INVALID_HANDLE;
4646         }
4647
4648         delete_on_close = (CVAL(pdata,0) ? True : False);
4649         dosmode = dos_mode(conn, fname, psbuf);
4650
4651         DEBUG(10,("smb_set_file_disposition_info: file %s, dosmode = %u, "
4652                 "delete_on_close = %u\n",
4653                 fsp->fsp_name,
4654                 (unsigned int)dosmode,
4655                 (unsigned int)delete_on_close ));
4656
4657         status = can_set_delete_on_close(fsp, delete_on_close, dosmode);
4658
4659         if (!NT_STATUS_IS_OK(status)) {
4660                 return status;
4661         }
4662
4663         /* The set is across all open files on this dev/inode pair. */
4664         if (!set_delete_on_close(fsp, delete_on_close, &current_user.ut)) {
4665                 return NT_STATUS_ACCESS_DENIED;
4666         }
4667         return NT_STATUS_OK;
4668 }
4669
4670 /****************************************************************************
4671  Deal with SMB_FILE_POSITION_INFORMATION.
4672 ****************************************************************************/
4673
4674 static NTSTATUS smb_file_position_information(connection_struct *conn,
4675                                 const char *pdata,
4676                                 int total_data,
4677                                 files_struct *fsp)
4678 {
4679         SMB_BIG_UINT position_information;
4680
4681         if (total_data < 8) {
4682                 return NT_STATUS_INVALID_PARAMETER;
4683         }
4684
4685         if (fsp == NULL) {
4686                 /* Ignore on pathname based set. */
4687                 return NT_STATUS_OK;
4688         }
4689
4690         position_information = (SMB_BIG_UINT)IVAL(pdata,0);
4691 #ifdef LARGE_SMB_OFF_T
4692         position_information |= (((SMB_BIG_UINT)IVAL(pdata,4)) << 32);
4693 #else /* LARGE_SMB_OFF_T */
4694         if (IVAL(pdata,4) != 0) {
4695                 /* more than 32 bits? */
4696                 return NT_STATUS_INVALID_PARAMETER;
4697         }
4698 #endif /* LARGE_SMB_OFF_T */
4699
4700         DEBUG(10,("smb_file_position_information: Set file position information for file %s to %.0f\n",
4701                 fsp->fsp_name, (double)position_information ));
4702         fsp->fh->position_information = position_information;
4703         return NT_STATUS_OK;
4704 }
4705
4706 /****************************************************************************
4707  Deal with SMB_FILE_MODE_INFORMATION.
4708 ****************************************************************************/
4709
4710 static NTSTATUS smb_file_mode_information(connection_struct *conn,
4711                                 const char *pdata,
4712                                 int total_data)
4713 {
4714         uint32 mode;
4715
4716         if (total_data < 4) {
4717                 return NT_STATUS_INVALID_PARAMETER;
4718         }
4719         mode = IVAL(pdata,0);
4720         if (mode != 0 && mode != 2 && mode != 4 && mode != 6) {
4721                 return NT_STATUS_INVALID_PARAMETER;
4722         }
4723         return NT_STATUS_OK;
4724 }
4725
4726 /****************************************************************************
4727  Deal with SMB_SET_FILE_UNIX_LINK (create a UNIX symlink).
4728 ****************************************************************************/
4729
4730 static NTSTATUS smb_set_file_unix_link(connection_struct *conn,
4731                                        struct smb_request *req,
4732                                        const char *pdata,
4733                                        int total_data,
4734                                        const char *fname)
4735 {
4736         pstring link_target;
4737         const char *newname = fname;
4738         NTSTATUS status = NT_STATUS_OK;
4739
4740         /* Set a symbolic link. */
4741         /* Don't allow this if follow links is false. */
4742
4743         if (total_data == 0) {
4744                 return NT_STATUS_INVALID_PARAMETER;
4745         }
4746
4747         if (!lp_symlinks(SNUM(conn))) {
4748                 return NT_STATUS_ACCESS_DENIED;
4749         }
4750
4751         srvstr_pull(pdata, req->flags2, link_target, pdata,
4752                     sizeof(link_target), total_data, STR_TERMINATE);
4753
4754         /* !widelinks forces the target path to be within the share. */
4755         /* This means we can interpret the target as a pathname. */
4756         if (!lp_widelinks(SNUM(conn))) {
4757                 pstring rel_name;
4758                 char *last_dirp = NULL;
4759
4760                 if (*link_target == '/') {
4761                         /* No absolute paths allowed. */
4762                         return NT_STATUS_ACCESS_DENIED;
4763                 }
4764                 pstrcpy(rel_name, newname);
4765                 last_dirp = strrchr_m(rel_name, '/');
4766                 if (last_dirp) {
4767                         last_dirp[1] = '\0';
4768                 } else {
4769                         pstrcpy(rel_name, "./");
4770                 }
4771                 pstrcat(rel_name, link_target);
4772
4773                 status = check_name(conn, rel_name);
4774                 if (!NT_STATUS_IS_OK(status)) {
4775                         return status;
4776                 }
4777         }
4778
4779         DEBUG(10,("smb_set_file_unix_link: SMB_SET_FILE_UNIX_LINK doing symlink %s -> %s\n",
4780                         newname, link_target ));
4781
4782         if (SMB_VFS_SYMLINK(conn,link_target,newname) != 0) {
4783                 return map_nt_error_from_unix(errno);
4784         }
4785
4786         return NT_STATUS_OK;
4787 }
4788
4789 /****************************************************************************
4790  Deal with SMB_SET_FILE_UNIX_HLINK (create a UNIX hard link).
4791 ****************************************************************************/
4792
4793 static NTSTATUS smb_set_file_unix_hlink(connection_struct *conn,
4794                                         struct smb_request *req,
4795                                         const char *pdata, int total_data,
4796                                         pstring fname)
4797 {
4798         pstring oldname;
4799         NTSTATUS status = NT_STATUS_OK;
4800
4801         /* Set a hard link. */
4802         if (total_data == 0) {
4803                 return NT_STATUS_INVALID_PARAMETER;
4804         }
4805
4806         srvstr_get_path(pdata, req->flags2, oldname, pdata,
4807                         sizeof(oldname), total_data, STR_TERMINATE, &status);
4808         if (!NT_STATUS_IS_OK(status)) {
4809                 return status;
4810         }
4811
4812         status = resolve_dfspath(conn, req->flags2 & FLAGS2_DFS_PATHNAMES,
4813                                  oldname);
4814         if (!NT_STATUS_IS_OK(status)) {
4815                 return status;
4816         }
4817
4818         DEBUG(10,("smb_set_file_unix_hlink: SMB_SET_FILE_UNIX_LINK doing hard link %s -> %s\n",
4819                 fname, oldname));
4820
4821         return hardlink_internals(conn, oldname, fname);
4822 }
4823
4824 /****************************************************************************
4825  Deal with SMB_FILE_RENAME_INFORMATION.
4826 ****************************************************************************/
4827
4828 static NTSTATUS smb_file_rename_information(connection_struct *conn,
4829                                             struct smb_request *req,
4830                                             const char *pdata, int total_data,
4831                                             files_struct *fsp, pstring fname)
4832 {
4833         BOOL overwrite;
4834         uint32 root_fid;
4835         uint32 len;
4836         pstring newname;
4837         pstring base_name;
4838         BOOL dest_has_wcard = False;
4839         NTSTATUS status = NT_STATUS_OK;
4840         char *p;
4841
4842         if (total_data < 13) {
4843                 return NT_STATUS_INVALID_PARAMETER;
4844         }
4845
4846         overwrite = (CVAL(pdata,0) ? True : False);
4847         root_fid = IVAL(pdata,4);
4848         len = IVAL(pdata,8);
4849
4850         if (len > (total_data - 12) || (len == 0) || (root_fid != 0)) {
4851                 return NT_STATUS_INVALID_PARAMETER;
4852         }
4853
4854         srvstr_get_path_wcard(pdata, req->flags2, newname, &pdata[12],
4855                               sizeof(newname), len, 0, &status,
4856                               &dest_has_wcard);
4857         if (!NT_STATUS_IS_OK(status)) {
4858                 return status;
4859         }
4860
4861         status = resolve_dfspath_wcard(conn,
4862                                        req->flags2 & FLAGS2_DFS_PATHNAMES,
4863                                        newname, &dest_has_wcard);
4864         if (!NT_STATUS_IS_OK(status)) {
4865                 return status;
4866         }
4867
4868         /* Check the new name has no '/' characters. */
4869         if (strchr_m(newname, '/')) {
4870                 return NT_STATUS_NOT_SUPPORTED;
4871         }
4872
4873         /* Create the base directory. */
4874         pstrcpy(base_name, fname);
4875         p = strrchr_m(base_name, '/');
4876         if (p) {
4877                 p[1] = '\0';
4878         } else {
4879                 pstrcpy(base_name, "./");
4880         }
4881         /* Append the new name. */
4882         pstrcat(base_name, newname);
4883
4884         if (fsp) {
4885                 DEBUG(10,("smb_file_rename_information: SMB_FILE_RENAME_INFORMATION (fnum %d) %s -> %s\n",
4886                         fsp->fnum, fsp->fsp_name, base_name ));
4887                 status = rename_internals_fsp(conn, fsp, base_name, 0, overwrite);
4888         } else {
4889                 DEBUG(10,("smb_file_rename_information: SMB_FILE_RENAME_INFORMATION %s -> %s\n",
4890                         fname, newname ));
4891                 status = rename_internals(conn, req, fname, base_name, 0,
4892                                           overwrite, False, dest_has_wcard);
4893         }
4894
4895         return status;
4896 }
4897
4898 /****************************************************************************
4899  Deal with SMB_SET_POSIX_ACL.
4900 ****************************************************************************/
4901
4902 #if defined(HAVE_POSIX_ACLS)
4903 static NTSTATUS smb_set_posix_acl(connection_struct *conn,
4904                                 const char *pdata,
4905                                 int total_data,
4906                                 files_struct *fsp,
4907                                 const char *fname,
4908                                 SMB_STRUCT_STAT *psbuf)
4909 {
4910         uint16 posix_acl_version;
4911         uint16 num_file_acls;
4912         uint16 num_def_acls;
4913         BOOL valid_file_acls = True;
4914         BOOL valid_def_acls = True;
4915
4916         if (total_data < SMB_POSIX_ACL_HEADER_SIZE) {
4917                 return NT_STATUS_INVALID_PARAMETER;
4918         }
4919         posix_acl_version = SVAL(pdata,0);
4920         num_file_acls = SVAL(pdata,2);
4921         num_def_acls = SVAL(pdata,4);
4922
4923         if (num_file_acls == SMB_POSIX_IGNORE_ACE_ENTRIES) {
4924                 valid_file_acls = False;
4925                 num_file_acls = 0;
4926         }
4927
4928         if (num_def_acls == SMB_POSIX_IGNORE_ACE_ENTRIES) {
4929                 valid_def_acls = False;
4930                 num_def_acls = 0;
4931         }
4932
4933         if (posix_acl_version != SMB_POSIX_ACL_VERSION) {
4934                 return NT_STATUS_INVALID_PARAMETER;
4935         }
4936
4937         if (total_data < SMB_POSIX_ACL_HEADER_SIZE +
4938                         (num_file_acls+num_def_acls)*SMB_POSIX_ACL_ENTRY_SIZE) {
4939                 return NT_STATUS_INVALID_PARAMETER;
4940         }
4941
4942         DEBUG(10,("smb_set_posix_acl: file %s num_file_acls = %u, num_def_acls = %u\n",
4943                 fname ? fname : fsp->fsp_name,
4944                 (unsigned int)num_file_acls,
4945                 (unsigned int)num_def_acls));
4946
4947         if (valid_file_acls && !set_unix_posix_acl(conn, fsp, fname, num_file_acls,
4948                         pdata + SMB_POSIX_ACL_HEADER_SIZE)) {
4949                 return map_nt_error_from_unix(errno);
4950         }
4951
4952         if (valid_def_acls && !set_unix_posix_default_acl(conn, fname, psbuf, num_def_acls,
4953                         pdata + SMB_POSIX_ACL_HEADER_SIZE +
4954                         (num_file_acls*SMB_POSIX_ACL_ENTRY_SIZE))) {
4955                 return map_nt_error_from_unix(errno);
4956         }
4957         return NT_STATUS_OK;
4958 }
4959 #endif
4960
4961 /****************************************************************************
4962  Deal with SMB_SET_POSIX_LOCK.
4963 ****************************************************************************/
4964
4965 static NTSTATUS smb_set_posix_lock(connection_struct *conn,
4966                                 char *inbuf,
4967                                 int length,
4968                                 const char *pdata,
4969                                 int total_data,
4970                                 files_struct *fsp)
4971 {
4972         SMB_BIG_UINT count;
4973         SMB_BIG_UINT offset;
4974         uint32 lock_pid;
4975         BOOL blocking_lock = False;
4976         enum brl_type lock_type;
4977         NTSTATUS status = NT_STATUS_OK;
4978
4979         if (fsp == NULL || fsp->fh->fd == -1) {
4980                 return NT_STATUS_INVALID_HANDLE;
4981         }
4982
4983         if (total_data != POSIX_LOCK_DATA_SIZE) {
4984                 return NT_STATUS_INVALID_PARAMETER;
4985         }
4986
4987         switch (SVAL(pdata, POSIX_LOCK_TYPE_OFFSET)) {
4988                 case POSIX_LOCK_TYPE_READ:
4989                         lock_type = READ_LOCK;
4990                         break;
4991                 case POSIX_LOCK_TYPE_WRITE:
4992                         /* Return the right POSIX-mappable error code for files opened read-only. */
4993                         if (!fsp->can_write) {
4994                                 return NT_STATUS_INVALID_HANDLE;
4995                         }
4996                         lock_type = WRITE_LOCK;
4997                         break;
4998                 case POSIX_LOCK_TYPE_UNLOCK:
4999                         lock_type = UNLOCK_LOCK;
5000                         break;
5001                 default:
5002                         return NT_STATUS_INVALID_PARAMETER;
5003         }
5004
5005         if (SVAL(pdata,POSIX_LOCK_FLAGS_OFFSET) == POSIX_LOCK_FLAG_NOWAIT) {
5006                 blocking_lock = False;
5007         } else if (SVAL(pdata,POSIX_LOCK_FLAGS_OFFSET) == POSIX_LOCK_FLAG_WAIT) {
5008                 blocking_lock = True;
5009         } else {
5010                 return NT_STATUS_INVALID_PARAMETER;
5011         }
5012
5013         if (!lp_blocking_locks(SNUM(conn))) {
5014                 blocking_lock = False;
5015         }
5016
5017         lock_pid = IVAL(pdata, POSIX_LOCK_PID_OFFSET);
5018 #if defined(HAVE_LONGLONG)
5019         offset = (((SMB_BIG_UINT) IVAL(pdata,(POSIX_LOCK_START_OFFSET+4))) << 32) |
5020                         ((SMB_BIG_UINT) IVAL(pdata,POSIX_LOCK_START_OFFSET));
5021         count = (((SMB_BIG_UINT) IVAL(pdata,(POSIX_LOCK_LEN_OFFSET+4))) << 32) |
5022                         ((SMB_BIG_UINT) IVAL(pdata,POSIX_LOCK_LEN_OFFSET));
5023 #else /* HAVE_LONGLONG */
5024         offset = (SMB_BIG_UINT)IVAL(pdata,POSIX_LOCK_START_OFFSET);
5025         count = (SMB_BIG_UINT)IVAL(pdata,POSIX_LOCK_LEN_OFFSET);
5026 #endif /* HAVE_LONGLONG */
5027
5028         DEBUG(10,("smb_set_posix_lock: file %s, lock_type = %u,"
5029                         "lock_pid = %u, count = %.0f, offset = %.0f\n",
5030                 fsp->fsp_name,
5031                 (unsigned int)lock_type,
5032                 (unsigned int)lock_pid,
5033                 (double)count,
5034                 (double)offset ));
5035
5036         if (lock_type == UNLOCK_LOCK) {
5037                 status = do_unlock(smbd_messaging_context(),
5038                                 fsp,
5039                                 lock_pid,
5040                                 count,
5041                                 offset,
5042                                 POSIX_LOCK);
5043         } else {
5044                 uint32 block_smbpid;
5045
5046                 struct byte_range_lock *br_lck = do_lock(smbd_messaging_context(),
5047                                                         fsp,
5048                                                         lock_pid,
5049                                                         count,
5050                                                         offset,
5051                                                         lock_type,
5052                                                         POSIX_LOCK,
5053                                                         blocking_lock,
5054                                                         &status,
5055                                                         &block_smbpid);
5056
5057                 if (br_lck && blocking_lock && ERROR_WAS_LOCK_DENIED(status)) {
5058                         /*
5059                          * A blocking lock was requested. Package up
5060                          * this smb into a queued request and push it
5061                          * onto the blocking lock queue.
5062                          */
5063                         if(push_blocking_lock_request(br_lck,
5064                                                 inbuf, length,
5065                                                 fsp,
5066                                                 -1, /* infinite timeout. */
5067                                                 0,
5068                                                 lock_pid,
5069                                                 lock_type,
5070                                                 POSIX_LOCK,
5071                                                 offset,
5072                                                 count,
5073                                                 block_smbpid)) {
5074                                 TALLOC_FREE(br_lck);
5075                                 return status;
5076                         }
5077                 }
5078                 TALLOC_FREE(br_lck);
5079         }
5080
5081         return status;
5082 }
5083
5084 /****************************************************************************
5085  Deal with SMB_INFO_STANDARD.
5086 ****************************************************************************/
5087
5088 static NTSTATUS smb_set_info_standard(connection_struct *conn,
5089                                         const char *pdata,
5090                                         int total_data,
5091                                         files_struct *fsp,
5092                                         const char *fname,
5093                                         const SMB_STRUCT_STAT *psbuf)
5094 {
5095         struct timespec ts[2];
5096
5097         if (total_data < 12) {
5098                 return NT_STATUS_INVALID_PARAMETER;
5099         }
5100
5101         /* access time */
5102         ts[0] = convert_time_t_to_timespec(srv_make_unix_date2(pdata+l1_fdateLastAccess));
5103         /* write time */
5104         ts[1] = convert_time_t_to_timespec(srv_make_unix_date2(pdata+l1_fdateLastWrite));
5105
5106         DEBUG(10,("smb_set_info_standard: file %s\n",
5107                 fname ? fname : fsp->fsp_name ));
5108
5109         return smb_set_file_time(conn,
5110                                 fsp,
5111                                 fname,
5112                                 psbuf,
5113                                 ts);
5114 }
5115
5116 /****************************************************************************
5117  Deal with SMB_SET_FILE_BASIC_INFO.
5118 ****************************************************************************/
5119
5120 static NTSTATUS smb_set_file_basic_info(connection_struct *conn,
5121                                         const char *pdata,
5122                                         int total_data,
5123                                         files_struct *fsp,
5124                                         const char *fname,
5125                                         SMB_STRUCT_STAT *psbuf)
5126 {
5127         /* Patch to do this correctly from Paul Eggert <eggert@twinsun.com>. */
5128         struct timespec write_time;
5129         struct timespec changed_time;
5130         uint32 dosmode = 0;
5131         struct timespec ts[2];
5132         NTSTATUS status = NT_STATUS_OK;
5133
5134         if (total_data < 36) {
5135                 return NT_STATUS_INVALID_PARAMETER;
5136         }
5137
5138         /* Set the attributes */
5139         dosmode = IVAL(pdata,32);
5140         status = smb_set_file_dosmode(conn,
5141                                         fname,
5142                                         psbuf,
5143                                         dosmode);
5144         if (!NT_STATUS_IS_OK(status)) {
5145                 return status;
5146         }
5147
5148         /* Ignore create time at offset pdata. */
5149
5150         /* access time */
5151         ts[0] = interpret_long_date(pdata+8);
5152
5153         write_time = interpret_long_date(pdata+16);
5154         changed_time = interpret_long_date(pdata+24);
5155
5156         /* mtime */
5157         ts[1] = timespec_min(&write_time, &changed_time);
5158
5159         if ((timespec_compare(&write_time, &ts[1]) == 1) && !null_timespec(write_time)) {
5160                 ts[1] = write_time;
5161         }
5162
5163         /* Prefer a defined time to an undefined one. */
5164         if (null_timespec(ts[1])) {
5165                 ts[1] = null_timespec(write_time) ? changed_time : write_time;
5166         }
5167
5168         DEBUG(10,("smb_set_file_basic_info: file %s\n",
5169                 fname ? fname : fsp->fsp_name ));
5170
5171         return smb_set_file_time(conn,
5172                                 fsp,
5173                                 fname,
5174                                 psbuf,
5175                                 ts);
5176 }
5177
5178 /****************************************************************************
5179  Deal with SMB_SET_FILE_ALLOCATION_INFO.
5180 ****************************************************************************/
5181
5182 static NTSTATUS smb_set_file_allocation_info(connection_struct *conn,
5183                                              struct smb_request *req,
5184                                         const char *pdata,
5185                                         int total_data,
5186                                         files_struct *fsp,
5187                                         const char *fname,
5188                                         SMB_STRUCT_STAT *psbuf)
5189 {
5190         SMB_BIG_UINT allocation_size = 0;
5191         NTSTATUS status = NT_STATUS_OK;
5192         files_struct *new_fsp = NULL;
5193
5194         if (!VALID_STAT(*psbuf)) {
5195                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
5196         }
5197
5198         if (total_data < 8) {
5199                 return NT_STATUS_INVALID_PARAMETER;
5200         }
5201
5202         allocation_size = (SMB_BIG_UINT)IVAL(pdata,0);
5203 #ifdef LARGE_SMB_OFF_T
5204         allocation_size |= (((SMB_BIG_UINT)IVAL(pdata,4)) << 32);
5205 #else /* LARGE_SMB_OFF_T */
5206         if (IVAL(pdata,4) != 0) {
5207                 /* more than 32 bits? */
5208                 return NT_STATUS_INVALID_PARAMETER;
5209         }
5210 #endif /* LARGE_SMB_OFF_T */
5211
5212         DEBUG(10,("smb_set_file_allocation_info: Set file allocation info for file %s to %.0f\n",
5213                         fname, (double)allocation_size ));
5214
5215         if (allocation_size) {
5216                 allocation_size = smb_roundup(conn, allocation_size);
5217         }
5218
5219         DEBUG(10,("smb_set_file_allocation_info: file %s : setting new allocation size to %.0f\n",
5220                         fname, (double)allocation_size ));
5221
5222         if (fsp && fsp->fh->fd != -1) {
5223                 /* Open file handle. */
5224                 /* Only change if needed. */
5225                 if (allocation_size != get_file_size(*psbuf)) {
5226                         if (vfs_allocate_file_space(fsp, allocation_size) == -1) {
5227                                 return map_nt_error_from_unix(errno);
5228                         }
5229                 }
5230                 /* But always update the time. */
5231                 if (null_timespec(fsp->pending_modtime)) {
5232                         /*
5233                          * This is equivalent to a write. Ensure it's seen immediately
5234                          * if there are no pending writes.
5235                          */
5236                         set_filetime(fsp->conn, fsp->fsp_name, timespec_current());
5237                 }
5238                 return NT_STATUS_OK;
5239         }
5240
5241         /* Pathname or stat or directory file. */
5242
5243         status = open_file_ntcreate(conn, req, fname, psbuf,
5244                                 FILE_WRITE_DATA,
5245                                 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
5246                                 FILE_OPEN,
5247                                 0,
5248                                 FILE_ATTRIBUTE_NORMAL,
5249                                 FORCE_OPLOCK_BREAK_TO_NONE,
5250                                 NULL, &new_fsp);
5251
5252         if (!NT_STATUS_IS_OK(status)) {
5253                 /* NB. We check for open_was_deferred in the caller. */
5254                 return status;
5255         }
5256
5257         /* Only change if needed. */
5258         if (allocation_size != get_file_size(*psbuf)) {
5259                 if (vfs_allocate_file_space(new_fsp, allocation_size) == -1) {
5260                         status = map_nt_error_from_unix(errno);
5261                         close_file(new_fsp,NORMAL_CLOSE);
5262                         return status;
5263                 }
5264         }
5265
5266         /* Changing the allocation size should set the last mod time. */
5267         /* Don't need to call set_filetime as this will be flushed on
5268          * close. */
5269
5270         fsp_set_pending_modtime(new_fsp, timespec_current());
5271
5272         close_file(new_fsp,NORMAL_CLOSE);
5273         return NT_STATUS_OK;
5274 }
5275
5276 /****************************************************************************
5277  Deal with SMB_SET_FILE_END_OF_FILE_INFO.
5278 ****************************************************************************/
5279
5280 static NTSTATUS smb_set_file_end_of_file_info(connection_struct *conn,
5281                                               struct smb_request *req,
5282                                         const char *pdata,
5283                                         int total_data,
5284                                         files_struct *fsp,
5285                                         const char *fname,
5286                                         SMB_STRUCT_STAT *psbuf)
5287 {
5288         SMB_OFF_T size;
5289
5290         if (total_data < 8) {
5291                 return NT_STATUS_INVALID_PARAMETER;
5292         }
5293
5294         size = IVAL(pdata,0);
5295 #ifdef LARGE_SMB_OFF_T
5296         size |= (((SMB_OFF_T)IVAL(pdata,4)) << 32);
5297 #else /* LARGE_SMB_OFF_T */
5298         if (IVAL(pdata,4) != 0) {
5299                 /* more than 32 bits? */
5300                 return NT_STATUS_INVALID_PARAMETER;
5301         }
5302 #endif /* LARGE_SMB_OFF_T */
5303         DEBUG(10,("smb_set_file_end_of_file_info: Set end of file info for "
5304                 "file %s to %.0f\n", fname, (double)size ));
5305
5306         return smb_set_file_size(conn, req,
5307                                 fsp,
5308                                 fname,
5309                                 psbuf,
5310                                 size);
5311 }
5312
5313 /****************************************************************************
5314  Allow a UNIX info mknod.
5315 ****************************************************************************/
5316
5317 static NTSTATUS smb_unix_mknod(connection_struct *conn,
5318                                         const char *pdata,
5319                                         int total_data,
5320                                         const char *fname,
5321                                         SMB_STRUCT_STAT *psbuf)
5322 {
5323         uint32 file_type = IVAL(pdata,56);
5324 #if defined(HAVE_MAKEDEV)
5325         uint32 dev_major = IVAL(pdata,60);
5326         uint32 dev_minor = IVAL(pdata,68);
5327 #endif
5328         SMB_DEV_T dev = (SMB_DEV_T)0;
5329         uint32 raw_unixmode = IVAL(pdata,84);
5330         NTSTATUS status;
5331         mode_t unixmode;
5332
5333         if (total_data < 100) {
5334                 return NT_STATUS_INVALID_PARAMETER;
5335         }
5336
5337         status = unix_perms_from_wire(conn, psbuf, raw_unixmode, PERM_NEW_FILE, &unixmode);
5338         if (!NT_STATUS_IS_OK(status)) {
5339                 return status;
5340         }
5341
5342 #if defined(HAVE_MAKEDEV)
5343         dev = makedev(dev_major, dev_minor);
5344 #endif
5345
5346         switch (file_type) {
5347 #if defined(S_IFIFO)
5348                 case UNIX_TYPE_FIFO:
5349                         unixmode |= S_IFIFO;
5350                         break;
5351 #endif
5352 #if defined(S_IFSOCK)
5353                 case UNIX_TYPE_SOCKET:
5354                         unixmode |= S_IFSOCK;
5355                         break;
5356 #endif
5357 #if defined(S_IFCHR)
5358                 case UNIX_TYPE_CHARDEV:
5359                         unixmode |= S_IFCHR;
5360                         break;
5361 #endif
5362 #if defined(S_IFBLK)
5363                 case UNIX_TYPE_BLKDEV:
5364                         unixmode |= S_IFBLK;
5365                         break;
5366 #endif
5367                 default:
5368                         return NT_STATUS_INVALID_PARAMETER;
5369         }
5370
5371         DEBUG(10,("smb_unix_mknod: SMB_SET_FILE_UNIX_BASIC doing mknod dev %.0f mode \
5372 0%o for file %s\n", (double)dev, (unsigned int)unixmode, fname ));
5373
5374         /* Ok - do the mknod. */
5375         if (SMB_VFS_MKNOD(conn, fname, unixmode, dev) != 0) {
5376                 return map_nt_error_from_unix(errno);
5377         }
5378
5379         /* If any of the other "set" calls fail we
5380          * don't want to end up with a half-constructed mknod.
5381          */
5382
5383         if (lp_inherit_perms(SNUM(conn))) {
5384                 inherit_access_acl(
5385                         conn, parent_dirname(fname),
5386                         fname, unixmode);
5387         }
5388
5389         if (SMB_VFS_STAT(conn, fname, psbuf) != 0) {
5390                 status = map_nt_error_from_unix(errno);
5391                 SMB_VFS_UNLINK(conn,fname);
5392                 return status;
5393         }
5394         return NT_STATUS_OK;
5395 }
5396
5397 /****************************************************************************
5398  Deal with SMB_SET_FILE_UNIX_BASIC.
5399 ****************************************************************************/
5400
5401 static NTSTATUS smb_set_file_unix_basic(connection_struct *conn,
5402                                         struct smb_request *req,
5403                                         const char *pdata,
5404                                         int total_data,
5405                                         files_struct *fsp,
5406                                         const char *fname,
5407                                         SMB_STRUCT_STAT *psbuf)
5408 {
5409         struct timespec ts[2];
5410         uint32 raw_unixmode;
5411         mode_t unixmode;
5412         SMB_OFF_T size = 0;
5413         uid_t set_owner = (uid_t)SMB_UID_NO_CHANGE;
5414         gid_t set_grp = (uid_t)SMB_GID_NO_CHANGE;
5415         NTSTATUS status = NT_STATUS_OK;
5416         BOOL delete_on_fail = False;
5417         enum perm_type ptype;
5418
5419         if (total_data < 100) {
5420                 return NT_STATUS_INVALID_PARAMETER;
5421         }
5422
5423         if(IVAL(pdata, 0) != SMB_SIZE_NO_CHANGE_LO &&
5424            IVAL(pdata, 4) != SMB_SIZE_NO_CHANGE_HI) {
5425                 size=IVAL(pdata,0); /* first 8 Bytes are size */
5426 #ifdef LARGE_SMB_OFF_T
5427                 size |= (((SMB_OFF_T)IVAL(pdata,4)) << 32);
5428 #else /* LARGE_SMB_OFF_T */
5429                 if (IVAL(pdata,4) != 0) {
5430                         /* more than 32 bits? */
5431                         return NT_STATUS_INVALID_PARAMETER;
5432                 }
5433 #endif /* LARGE_SMB_OFF_T */
5434         }
5435
5436         ts[0] = interpret_long_date(pdata+24); /* access_time */
5437         ts[1] = interpret_long_date(pdata+32); /* modification_time */
5438         set_owner = (uid_t)IVAL(pdata,40);
5439         set_grp = (gid_t)IVAL(pdata,48);
5440         raw_unixmode = IVAL(pdata,84);
5441
5442         if (VALID_STAT(*psbuf)) {
5443                 if (S_ISDIR(psbuf->st_mode)) {
5444                         ptype = PERM_EXISTING_DIR;
5445                 } else {
5446                         ptype = PERM_EXISTING_FILE;
5447                 }
5448         } else {
5449                 ptype = PERM_NEW_FILE;
5450         }
5451
5452         status = unix_perms_from_wire(conn, psbuf, raw_unixmode, ptype, &unixmode);
5453         if (!NT_STATUS_IS_OK(status)) {
5454                 return status;
5455         }
5456
5457         DEBUG(10,("smb_set_file_unix_basic: SMB_SET_FILE_UNIX_BASIC: name = %s \
5458 size = %.0f, uid = %u, gid = %u, raw perms = 0%o\n",
5459                 fname, (double)size, (unsigned int)set_owner, (unsigned int)set_grp, (int)raw_unixmode));
5460
5461         if (!VALID_STAT(*psbuf)) {
5462                 /*
5463                  * The only valid use of this is to create character and block
5464                  * devices, and named pipes. This is deprecated (IMHO) and
5465                  * a new info level should be used for mknod. JRA.
5466                  */
5467
5468                 status = smb_unix_mknod(conn,
5469                                         pdata,
5470                                         total_data,
5471                                         fname,
5472                                         psbuf);
5473                 if (!NT_STATUS_IS_OK(status)) {
5474                         return status;
5475                 }
5476
5477                 /* Ensure we don't try and change anything else. */
5478                 raw_unixmode = SMB_MODE_NO_CHANGE;
5479                 size = get_file_size(*psbuf);
5480                 ts[0] = get_atimespec(psbuf);
5481                 ts[1] = get_mtimespec(psbuf);
5482                 /*
5483                  * We continue here as we might want to change the
5484                  * owner uid/gid.
5485                  */
5486                 delete_on_fail = True;
5487         }
5488
5489 #if 1
5490         /* Horrible backwards compatibility hack as an old server bug
5491          * allowed a CIFS client bug to remain unnoticed :-(. JRA.
5492          * */
5493
5494         if (!size) {
5495                 size = get_file_size(*psbuf);
5496         }
5497 #endif
5498
5499         /*
5500          * Deal with the UNIX specific mode set.
5501          */
5502
5503         if (raw_unixmode != SMB_MODE_NO_CHANGE) {
5504                 DEBUG(10,("smb_set_file_unix_basic: SMB_SET_FILE_UNIX_BASIC setting mode 0%o for file %s\n",
5505                         (unsigned int)unixmode, fname ));
5506                 if (SMB_VFS_CHMOD(conn, fname, unixmode) != 0) {
5507                         return map_nt_error_from_unix(errno);
5508                 }
5509         }
5510
5511         /*
5512          * Deal with the UNIX specific uid set.
5513          */
5514
5515         if ((set_owner != (uid_t)SMB_UID_NO_CHANGE) && (psbuf->st_uid != set_owner)) {
5516                 int ret;
5517
5518                 DEBUG(10,("smb_set_file_unix_basic: SMB_SET_FILE_UNIX_BASIC changing owner %u for path %s\n",
5519                         (unsigned int)set_owner, fname ));
5520
5521                 if (S_ISLNK(psbuf->st_mode)) {
5522                         ret = SMB_VFS_LCHOWN(conn, fname, set_owner, (gid_t)-1);
5523                 } else {
5524                         ret = SMB_VFS_CHOWN(conn, fname, set_owner, (gid_t)-1);
5525                 }
5526
5527                 if (ret != 0) {
5528                         status = map_nt_error_from_unix(errno);
5529                         if (delete_on_fail) {
5530                                 SMB_VFS_UNLINK(conn,fname);
5531                         }
5532                         return status;
5533                 }
5534         }
5535
5536         /*
5537          * Deal with the UNIX specific gid set.
5538          */
5539
5540         if ((set_grp != (uid_t)SMB_GID_NO_CHANGE) && (psbuf->st_gid != set_grp)) {
5541                 DEBUG(10,("smb_set_file_unix_basic: SMB_SET_FILE_UNIX_BASIC changing group %u for file %s\n",
5542                         (unsigned int)set_owner, fname ));
5543                 if (SMB_VFS_CHOWN(conn, fname, (uid_t)-1, set_grp) != 0) {
5544                         status = map_nt_error_from_unix(errno);
5545                         if (delete_on_fail) {
5546                                 SMB_VFS_UNLINK(conn,fname);
5547                         }
5548                         return status;
5549                 }
5550         }
5551
5552         /* Deal with any size changes. */
5553
5554         status = smb_set_file_size(conn, req,
5555                                 fsp,
5556                                 fname,
5557                                 psbuf,
5558                                 size);
5559         if (!NT_STATUS_IS_OK(status)) {
5560                 return status;
5561         }
5562
5563         /* Deal with any time changes. */
5564
5565         return smb_set_file_time(conn,
5566                                 fsp,
5567                                 fname,
5568                                 psbuf,
5569                                 ts);
5570 }
5571
5572 /****************************************************************************
5573  Deal with SMB_SET_FILE_UNIX_INFO2.
5574 ****************************************************************************/
5575
5576 static NTSTATUS smb_set_file_unix_info2(connection_struct *conn,
5577                                         struct smb_request *req,
5578                                         const char *pdata,
5579                                         int total_data,
5580                                         files_struct *fsp,
5581                                         const char *fname,
5582                                         SMB_STRUCT_STAT *psbuf)
5583 {
5584         NTSTATUS status;
5585         uint32 smb_fflags;
5586         uint32 smb_fmask;
5587
5588         if (total_data < 116) {
5589                 return NT_STATUS_INVALID_PARAMETER;
5590         }
5591
5592         /* Start by setting all the fields that are common between UNIX_BASIC
5593          * and UNIX_INFO2.
5594          */
5595         status = smb_set_file_unix_basic(conn, req, pdata, total_data,
5596                                 fsp, fname, psbuf);
5597         if (!NT_STATUS_IS_OK(status)) {
5598                 return status;
5599         }
5600
5601         smb_fflags = IVAL(pdata, 108);
5602         smb_fmask = IVAL(pdata, 112);
5603
5604         /* NB: We should only attempt to alter the file flags if the client
5605          * sends a non-zero mask.
5606          */
5607         if (smb_fmask != 0) {
5608                 int stat_fflags = 0;
5609
5610                 if (!map_info2_flags_to_sbuf(psbuf, smb_fflags, smb_fmask,
5611                             &stat_fflags)) {
5612                         /* Client asked to alter a flag we don't understand. */
5613                         return NT_STATUS_INVALID_PARAMETER;
5614                 }
5615
5616                 if (fsp && fsp->fh->fd != -1) {
5617                         /* XXX: we should be  using SMB_VFS_FCHFLAGS here. */
5618                         return NT_STATUS_NOT_SUPPORTED;
5619                 } else {
5620                         if (SMB_VFS_CHFLAGS(conn, fname, stat_fflags) != 0) {
5621                                 return map_nt_error_from_unix(errno);
5622                         }
5623                 }
5624         }
5625
5626         /* XXX: need to add support for changing the create_time here. You
5627          * can do this for paths on Darwin with setattrlist(2). The right way
5628          * to hook this up is probably by extending the VFS utimes interface.
5629          */
5630
5631         return NT_STATUS_OK;
5632 }
5633
5634 /****************************************************************************
5635  Create a directory with POSIX semantics.
5636 ****************************************************************************/
5637
5638 static NTSTATUS smb_posix_mkdir(connection_struct *conn,
5639                                 struct smb_request *req,
5640                                 char **ppdata,
5641                                 int total_data,
5642                                 const char *fname,
5643                                 SMB_STRUCT_STAT *psbuf,
5644                                 int *pdata_return_size)
5645 {
5646         NTSTATUS status = NT_STATUS_OK;
5647         uint32 raw_unixmode = 0;
5648         uint32 mod_unixmode = 0;
5649         mode_t unixmode = (mode_t)0;
5650         files_struct *fsp = NULL;
5651         uint16 info_level_return = 0;
5652         int info;
5653         char *pdata = *ppdata;
5654
5655         if (total_data < 18) {
5656                 return NT_STATUS_INVALID_PARAMETER;
5657         }
5658
5659         raw_unixmode = IVAL(pdata,8);
5660         /* Next 4 bytes are not yet defined. */
5661
5662         status = unix_perms_from_wire(conn, psbuf, raw_unixmode, PERM_NEW_DIR, &unixmode);
5663         if (!NT_STATUS_IS_OK(status)) {
5664                 return status;
5665         }
5666
5667         mod_unixmode = (uint32)unixmode | FILE_FLAG_POSIX_SEMANTICS;
5668
5669         DEBUG(10,("smb_posix_mkdir: file %s, mode 0%o\n",
5670                 fname, (unsigned int)unixmode ));
5671
5672         status = open_directory(conn, req,
5673                                 fname,
5674                                 psbuf,
5675                                 FILE_READ_ATTRIBUTES, /* Just a stat open */
5676                                 FILE_SHARE_NONE, /* Ignored for stat opens */
5677                                 FILE_CREATE,
5678                                 0,
5679                                 mod_unixmode,
5680                                 &info,
5681                                 &fsp);
5682
5683         if (NT_STATUS_IS_OK(status)) {
5684                 close_file(fsp, NORMAL_CLOSE);
5685         }
5686
5687         info_level_return = SVAL(pdata,16);
5688
5689         if (info_level_return == SMB_QUERY_FILE_UNIX_BASIC) {
5690                 *pdata_return_size = 12 + SMB_FILE_UNIX_BASIC_SIZE;
5691         } else if (info_level_return ==  SMB_QUERY_FILE_UNIX_INFO2) {
5692                 *pdata_return_size = 12 + SMB_FILE_UNIX_INFO2_SIZE;
5693         } else {
5694                 *pdata_return_size = 12;
5695         }
5696
5697         /* Realloc the data size */
5698         *ppdata = (char *)SMB_REALLOC(*ppdata,*pdata_return_size);
5699         if (*ppdata == NULL) {
5700                 *pdata_return_size = 0;
5701                 return NT_STATUS_NO_MEMORY;
5702         }
5703         pdata = *ppdata;
5704
5705         SSVAL(pdata,0,NO_OPLOCK_RETURN);
5706         SSVAL(pdata,2,0); /* No fnum. */
5707         SIVAL(pdata,4,info); /* Was directory created. */
5708
5709         switch (info_level_return) {
5710                 case SMB_QUERY_FILE_UNIX_BASIC:
5711                         SSVAL(pdata,8,SMB_QUERY_FILE_UNIX_BASIC);
5712                         SSVAL(pdata,10,0); /* Padding. */
5713                         store_file_unix_basic(conn, pdata + 12, fsp, psbuf);
5714                         break;
5715                 case SMB_QUERY_FILE_UNIX_INFO2:
5716                         SSVAL(pdata,8,SMB_QUERY_FILE_UNIX_INFO2);
5717                         SSVAL(pdata,10,0); /* Padding. */
5718                         store_file_unix_basic_info2(conn, pdata + 12, fsp, psbuf);
5719                         break;
5720                 default:
5721                         SSVAL(pdata,8,SMB_NO_INFO_LEVEL_RETURNED);
5722                         SSVAL(pdata,10,0); /* Padding. */
5723                         break;
5724         }
5725
5726         return status;
5727 }
5728
5729 /****************************************************************************
5730  Open/Create a file with POSIX semantics.
5731 ****************************************************************************/
5732
5733 static NTSTATUS smb_posix_open(connection_struct *conn,
5734                                struct smb_request *req,
5735                                 char **ppdata,
5736                                 int total_data,
5737                                 const char *fname,
5738                                 SMB_STRUCT_STAT *psbuf,
5739                                 int *pdata_return_size)
5740 {
5741         BOOL extended_oplock_granted = False;
5742         char *pdata = *ppdata;
5743         uint32 flags = 0;
5744         uint32 wire_open_mode = 0;
5745         uint32 raw_unixmode = 0;
5746         uint32 mod_unixmode = 0;
5747         uint32 create_disp = 0;
5748         uint32 access_mask = 0;
5749         uint32 create_options = 0;
5750         NTSTATUS status = NT_STATUS_OK;
5751         mode_t unixmode = (mode_t)0;
5752         files_struct *fsp = NULL;
5753         int oplock_request = 0;
5754         int info = 0;
5755         uint16 info_level_return = 0;
5756
5757         if (total_data < 18) {
5758                 return NT_STATUS_INVALID_PARAMETER;
5759         }
5760
5761         flags = IVAL(pdata,0);
5762         oplock_request = (flags & REQUEST_OPLOCK) ? EXCLUSIVE_OPLOCK : 0;
5763         if (oplock_request) {
5764                 oplock_request |= (flags & REQUEST_BATCH_OPLOCK) ? BATCH_OPLOCK : 0;
5765         }
5766
5767         wire_open_mode = IVAL(pdata,4);
5768
5769         if (wire_open_mode == (SMB_O_CREAT|SMB_O_DIRECTORY)) {
5770                 return smb_posix_mkdir(conn, req,
5771                                         ppdata,
5772                                         total_data,
5773                                         fname,
5774                                         psbuf,
5775                                         pdata_return_size);
5776         }
5777
5778         switch (wire_open_mode & SMB_ACCMODE) {
5779                 case SMB_O_RDONLY:
5780                         access_mask = FILE_READ_DATA;
5781                         break;
5782                 case SMB_O_WRONLY:
5783                         access_mask = FILE_WRITE_DATA;
5784                         break;
5785                 case SMB_O_RDWR:
5786                         access_mask = FILE_READ_DATA|FILE_WRITE_DATA;
5787                         break;
5788                 default:
5789                         DEBUG(5,("smb_posix_open: invalid open mode 0x%x\n",
5790                                 (unsigned int)wire_open_mode ));
5791                         return NT_STATUS_INVALID_PARAMETER;
5792         }
5793
5794         wire_open_mode &= ~SMB_ACCMODE;
5795
5796         if((wire_open_mode & (SMB_O_CREAT | SMB_O_EXCL)) == (SMB_O_CREAT | SMB_O_EXCL)) {
5797                 create_disp = FILE_CREATE;
5798         } else if((wire_open_mode & (SMB_O_CREAT | SMB_O_TRUNC)) == (SMB_O_CREAT | SMB_O_TRUNC)) {
5799                 create_disp = FILE_OVERWRITE_IF;
5800         } else if((wire_open_mode & SMB_O_CREAT) == SMB_O_CREAT) {
5801                 create_disp = FILE_OPEN_IF;
5802         } else {
5803                 DEBUG(5,("smb_posix_open: invalid create mode 0x%x\n",
5804                         (unsigned int)wire_open_mode ));
5805                 return NT_STATUS_INVALID_PARAMETER;
5806         }
5807
5808         raw_unixmode = IVAL(pdata,8);
5809         /* Next 4 bytes are not yet defined. */
5810
5811         status = unix_perms_from_wire(conn,
5812                                 psbuf,
5813                                 raw_unixmode,
5814                                 VALID_STAT(*psbuf) ? PERM_EXISTING_FILE : PERM_NEW_FILE,
5815                                 &unixmode);
5816
5817         if (!NT_STATUS_IS_OK(status)) {
5818                 return status;
5819         }
5820
5821         mod_unixmode = (uint32)unixmode | FILE_FLAG_POSIX_SEMANTICS;
5822
5823         if (wire_open_mode & SMB_O_SYNC) {
5824                 create_options |= FILE_WRITE_THROUGH;
5825         }
5826         if (wire_open_mode & SMB_O_APPEND) {
5827                 access_mask |= FILE_APPEND_DATA;
5828         }
5829         if (wire_open_mode & SMB_O_DIRECT) {
5830                 mod_unixmode |= FILE_FLAG_NO_BUFFERING;
5831         }
5832
5833         DEBUG(10,("smb_posix_open: file %s, smb_posix_flags = %u, mode 0%o\n",
5834                 fname,
5835                 (unsigned int)wire_open_mode,
5836                 (unsigned int)unixmode ));
5837
5838         status = open_file_ntcreate(conn, req,
5839                                 fname,
5840                                 psbuf,
5841                                 access_mask,
5842                                 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
5843                                 create_disp,
5844                                 0,              /* no create options yet. */
5845                                 mod_unixmode,
5846                                 oplock_request,
5847                                 &info,
5848                                 &fsp);
5849
5850         if (!NT_STATUS_IS_OK(status)) {
5851                 return status;
5852         }
5853
5854         if (oplock_request && lp_fake_oplocks(SNUM(conn))) {
5855                 extended_oplock_granted = True;
5856         }
5857
5858         if(oplock_request && EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type)) {
5859                 extended_oplock_granted = True;
5860         }
5861
5862         info_level_return = SVAL(pdata,16);
5863
5864         /* Allocate the correct return size. */
5865
5866         if (info_level_return == SMB_QUERY_FILE_UNIX_BASIC) {
5867                 *pdata_return_size = 12 + SMB_FILE_UNIX_BASIC_SIZE;
5868         } else if (info_level_return ==  SMB_QUERY_FILE_UNIX_INFO2) {
5869                 *pdata_return_size = 12 + SMB_FILE_UNIX_INFO2_SIZE;
5870         } else {
5871                 *pdata_return_size = 12;
5872         }
5873
5874         /* Realloc the data size */
5875         *ppdata = (char *)SMB_REALLOC(*ppdata,*pdata_return_size);
5876         if (*ppdata == NULL) {
5877                 close_file(fsp,ERROR_CLOSE);
5878                 *pdata_return_size = 0;
5879                 return NT_STATUS_NO_MEMORY;
5880         }
5881         pdata = *ppdata;
5882
5883         if (extended_oplock_granted) {
5884                 if (flags & REQUEST_BATCH_OPLOCK) {
5885                         SSVAL(pdata,0, BATCH_OPLOCK_RETURN);
5886                 } else {
5887                         SSVAL(pdata,0, EXCLUSIVE_OPLOCK_RETURN);
5888                 }
5889         } else if (fsp->oplock_type == LEVEL_II_OPLOCK) {
5890                 SSVAL(pdata,0, LEVEL_II_OPLOCK_RETURN);
5891         } else {
5892                 SSVAL(pdata,0,NO_OPLOCK_RETURN);
5893         }
5894
5895         SSVAL(pdata,2,fsp->fnum);
5896         SIVAL(pdata,4,info); /* Was file created etc. */
5897
5898         switch (info_level_return) {
5899                 case SMB_QUERY_FILE_UNIX_BASIC:
5900                         SSVAL(pdata,8,SMB_QUERY_FILE_UNIX_BASIC);
5901                         SSVAL(pdata,10,0); /* padding. */
5902                         store_file_unix_basic(conn, pdata + 12, fsp, psbuf);
5903                         break;
5904                 case SMB_QUERY_FILE_UNIX_INFO2:
5905                         SSVAL(pdata,8,SMB_QUERY_FILE_UNIX_INFO2);
5906                         SSVAL(pdata,10,0); /* padding. */
5907                         store_file_unix_basic_info2(conn, pdata + 12, fsp, psbuf);
5908                         break;
5909                 default:
5910                         SSVAL(pdata,8,SMB_NO_INFO_LEVEL_RETURNED);
5911                         SSVAL(pdata,10,0); /* padding. */
5912                         break;
5913         }
5914         return NT_STATUS_OK;
5915 }
5916
5917 /****************************************************************************
5918  Delete a file with POSIX semantics.
5919 ****************************************************************************/
5920
5921 static NTSTATUS smb_posix_unlink(connection_struct *conn,
5922                                  struct smb_request *req,
5923                                 const char *pdata,
5924                                 int total_data,
5925                                 const char *fname,
5926                                 SMB_STRUCT_STAT *psbuf)
5927 {
5928         NTSTATUS status = NT_STATUS_OK;
5929         files_struct *fsp = NULL;
5930         uint16 flags = 0;
5931         char del = 1;
5932         int info = 0;
5933         int i;
5934         struct share_mode_lock *lck = NULL;
5935
5936         if (total_data < 2) {
5937                 return NT_STATUS_INVALID_PARAMETER;
5938         }
5939
5940         flags = SVAL(pdata,0);
5941
5942         if (!VALID_STAT(*psbuf)) {
5943                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
5944         }
5945
5946         if ((flags == SMB_POSIX_UNLINK_DIRECTORY_TARGET) &&
5947                         !VALID_STAT_OF_DIR(*psbuf)) {
5948                 return NT_STATUS_NOT_A_DIRECTORY;
5949         }
5950
5951         DEBUG(10,("smb_posix_unlink: %s %s\n",
5952                 (flags == SMB_POSIX_UNLINK_DIRECTORY_TARGET) ? "directory" : "file",
5953                 fname));
5954
5955         if (VALID_STAT_OF_DIR(*psbuf)) {
5956                 status = open_directory(conn, req,
5957                                         fname,
5958                                         psbuf,
5959                                         DELETE_ACCESS,
5960                                         FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
5961                                         FILE_OPEN,
5962                                         0,
5963                                         FILE_FLAG_POSIX_SEMANTICS|0777,
5964                                         &info,
5965                                         &fsp);
5966         } else {
5967
5968                 status = open_file_ntcreate(conn, req,
5969                                 fname,
5970                                 psbuf,
5971                                 DELETE_ACCESS,
5972                                 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
5973                                 FILE_OPEN,
5974                                 0,
5975                                 FILE_FLAG_POSIX_SEMANTICS|0777,
5976                                 0, /* No oplock, but break existing ones. */
5977                                 &info,
5978                                 &fsp);
5979         }
5980
5981         if (!NT_STATUS_IS_OK(status)) {
5982                 return status;
5983         }
5984
5985         /*
5986          * Don't lie to client. If we can't really delete due to
5987          * non-POSIX opens return SHARING_VIOLATION.
5988          */
5989
5990         lck = get_share_mode_lock(NULL, fsp->file_id, NULL, NULL);
5991         if (lck == NULL) {
5992                 DEBUG(0, ("smb_posix_unlink: Could not get share mode "
5993                         "lock for file %s\n", fsp->fsp_name));
5994                 close_file(fsp, NORMAL_CLOSE);
5995                 return NT_STATUS_INVALID_PARAMETER;
5996         }
5997
5998         /*
5999          * See if others still have the file open. If this is the case, then
6000          * don't delete. If all opens are POSIX delete we can set the delete
6001          * on close disposition.
6002          */
6003         for (i=0; i<lck->num_share_modes; i++) {
6004                 struct share_mode_entry *e = &lck->share_modes[i];
6005                 if (is_valid_share_mode_entry(e)) {
6006                         if (e->flags & SHARE_MODE_FLAG_POSIX_OPEN) {
6007                                 continue;
6008                         }
6009                         /* Fail with sharing violation. */
6010                         close_file(fsp, NORMAL_CLOSE);
6011                         TALLOC_FREE(lck);
6012                         return NT_STATUS_SHARING_VIOLATION;
6013                 }
6014         }
6015
6016         /*
6017          * Set the delete on close.
6018          */
6019         status = smb_set_file_disposition_info(conn,
6020                                                 &del,
6021                                                 1,
6022                                                 fsp,
6023                                                 fname,
6024                                                 psbuf);
6025
6026         if (!NT_STATUS_IS_OK(status)) {
6027                 close_file(fsp, NORMAL_CLOSE);
6028                 TALLOC_FREE(lck);
6029                 return status;
6030         }
6031         TALLOC_FREE(lck);
6032         return close_file(fsp, NORMAL_CLOSE);
6033 }
6034
6035 /****************************************************************************
6036  Reply to a TRANS2_SETFILEINFO (set file info by fileid or pathname).
6037 ****************************************************************************/
6038
6039 static int call_trans2setfilepathinfo(connection_struct *conn,
6040                                       struct smb_request *req,
6041                                       char *inbuf, char *outbuf, int length,
6042                                       int bufsize,
6043                                         unsigned int tran_call,
6044                                         char **pparams, int total_params, char **ppdata, int total_data,
6045                                         unsigned int max_data_bytes)
6046 {
6047         char *params = *pparams;
6048         char *pdata = *ppdata;
6049         uint16 info_level;
6050         SMB_STRUCT_STAT sbuf;
6051         pstring fname;
6052         files_struct *fsp = NULL;
6053         NTSTATUS status = NT_STATUS_OK;
6054         int data_return_size = 0;
6055
6056         if (!params) {
6057                 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
6058         }
6059
6060         ZERO_STRUCT(sbuf);
6061
6062         if (tran_call == TRANSACT2_SETFILEINFO) {
6063                 if (total_params < 4) {
6064                         return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
6065                 }
6066
6067                 fsp = file_fsp(SVAL(params,0));
6068                 info_level = SVAL(params,2);
6069
6070                 if(fsp && (fsp->is_directory || fsp->fh->fd == -1)) {
6071                         /*
6072                          * This is actually a SETFILEINFO on a directory
6073                          * handle (returned from an NT SMB). NT5.0 seems
6074                          * to do this call. JRA.
6075                          */
6076                         pstrcpy(fname, fsp->fsp_name);
6077                         if (INFO_LEVEL_IS_UNIX(info_level)) {
6078                                 /* Always do lstat for UNIX calls. */
6079                                 if (SMB_VFS_LSTAT(conn,fname,&sbuf)) {
6080                                         DEBUG(3,("call_trans2setfilepathinfo: SMB_VFS_LSTAT of %s failed (%s)\n",fname,strerror(errno)));
6081                                         return UNIXERROR(ERRDOS,ERRbadpath);
6082                                 }
6083                         } else {
6084                                 if (SMB_VFS_STAT(conn,fname,&sbuf) != 0) {
6085                                         DEBUG(3,("call_trans2setfilepathinfo: fileinfo of %s failed (%s)\n",fname,strerror(errno)));
6086                                         return UNIXERROR(ERRDOS,ERRbadpath);
6087                                 }
6088                         }
6089                 } else if (fsp && fsp->print_file) {
6090                         /*
6091                          * Doing a DELETE_ON_CLOSE should cancel a print job.
6092                          */
6093                         if ((info_level == SMB_SET_FILE_DISPOSITION_INFO) && CVAL(pdata,0)) {
6094                                 fsp->fh->private_options |= FILE_DELETE_ON_CLOSE;
6095
6096                                 DEBUG(3,("call_trans2setfilepathinfo: Cancelling print job (%s)\n", fsp->fsp_name ));
6097
6098                                 SSVAL(params,0,0);
6099                                 send_trans2_replies(inbuf, outbuf, bufsize, params, 2, *ppdata, 0, max_data_bytes);
6100                                 return(-1);
6101                         } else
6102                                 return (UNIXERROR(ERRDOS,ERRbadpath));
6103             } else {
6104                         /*
6105                          * Original code - this is an open file.
6106                          */
6107                         CHECK_FSP(fsp,conn);
6108
6109                         pstrcpy(fname, fsp->fsp_name);
6110
6111                         if (SMB_VFS_FSTAT(fsp, fsp->fh->fd, &sbuf) != 0) {
6112                                 DEBUG(3,("call_trans2setfilepathinfo: fstat of fnum %d failed (%s)\n",fsp->fnum, strerror(errno)));
6113                                 return(UNIXERROR(ERRDOS,ERRbadfid));
6114                         }
6115                 }
6116         } else {
6117                 /* set path info */
6118                 if (total_params < 7) {
6119                         return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
6120                 }
6121
6122                 info_level = SVAL(params,0);
6123                 srvstr_get_path(params, req->flags2, fname, &params[6],
6124                                 sizeof(fname), total_params - 6, STR_TERMINATE,
6125                                 &status);
6126                 if (!NT_STATUS_IS_OK(status)) {
6127                         return ERROR_NT(status);
6128                 }
6129
6130                 status = resolve_dfspath(conn,
6131                                          req->flags2 & FLAGS2_DFS_PATHNAMES,
6132                                          fname);
6133                 if (!NT_STATUS_IS_OK(status)) {
6134                         if (NT_STATUS_EQUAL(status,NT_STATUS_PATH_NOT_COVERED)) {
6135                                 return ERROR_BOTH(NT_STATUS_PATH_NOT_COVERED, ERRSRV, ERRbadpath);
6136                         }
6137                         return ERROR_NT(status);
6138                 }
6139
6140                 status = unix_convert(conn, fname, False, NULL, &sbuf);
6141                 if (!NT_STATUS_IS_OK(status)) {
6142                         return ERROR_NT(status);
6143                 }
6144
6145                 status = check_name(conn, fname);
6146                 if (!NT_STATUS_IS_OK(status)) {
6147                         return ERROR_NT(status);
6148                 }
6149
6150                 if (INFO_LEVEL_IS_UNIX(info_level)) {
6151                         /*
6152                          * For CIFS UNIX extensions the target name may not exist.
6153                          */
6154
6155                         /* Always do lstat for UNIX calls. */
6156                         SMB_VFS_LSTAT(conn,fname,&sbuf);
6157
6158                 } else if (!VALID_STAT(sbuf) && SMB_VFS_STAT(conn,fname,&sbuf)) {
6159                         DEBUG(3,("call_trans2setfilepathinfo: SMB_VFS_STAT of %s failed (%s)\n",fname,strerror(errno)));
6160                         return UNIXERROR(ERRDOS,ERRbadpath);
6161                 }
6162         }
6163
6164         if (!CAN_WRITE(conn)) {
6165                 return ERROR_DOS(ERRSRV,ERRaccess);
6166         }
6167
6168         if (INFO_LEVEL_IS_UNIX(info_level) && !lp_unix_extensions()) {
6169                 return ERROR_NT(NT_STATUS_INVALID_LEVEL);
6170         }
6171
6172         DEBUG(3,("call_trans2setfilepathinfo(%d) %s (fnum %d) info_level=%d totdata=%d\n",
6173                 tran_call,fname, fsp ? fsp->fnum : -1, info_level,total_data));
6174
6175         /* Realloc the parameter size */
6176         *pparams = (char *)SMB_REALLOC(*pparams,2);
6177         if (*pparams == NULL) {
6178                 return ERROR_NT(NT_STATUS_NO_MEMORY);
6179         }
6180         params = *pparams;
6181
6182         SSVAL(params,0,0);
6183
6184         if (fsp && !null_timespec(fsp->pending_modtime)) {
6185                 /* the pending modtime overrides the current modtime */
6186                 set_mtimespec(&sbuf, fsp->pending_modtime);
6187         }
6188
6189         switch (info_level) {
6190
6191                 case SMB_INFO_STANDARD:
6192                 {
6193                         status = smb_set_info_standard(conn,
6194                                         pdata,
6195                                         total_data,
6196                                         fsp,
6197                                         fname,
6198                                         &sbuf);
6199                         break;
6200                 }
6201
6202                 case SMB_INFO_SET_EA:
6203                 {
6204                         status = smb_info_set_ea(conn,
6205                                                 pdata,
6206                                                 total_data,
6207                                                 fsp,
6208                                                 fname);
6209                         break;
6210                 }
6211
6212                 case SMB_SET_FILE_BASIC_INFO:
6213                 case SMB_FILE_BASIC_INFORMATION:
6214                 {
6215                         status = smb_set_file_basic_info(conn,
6216                                                         pdata,
6217                                                         total_data,
6218                                                         fsp,
6219                                                         fname,
6220                                                         &sbuf);
6221                         break;
6222                 }
6223
6224                 case SMB_FILE_ALLOCATION_INFORMATION:
6225                 case SMB_SET_FILE_ALLOCATION_INFO:
6226                 {
6227                         status = smb_set_file_allocation_info(conn, req,
6228                                                                 pdata,
6229                                                                 total_data,
6230                                                                 fsp,
6231                                                                 fname,
6232                                                                 &sbuf);
6233                         break;
6234                 }
6235
6236                 case SMB_FILE_END_OF_FILE_INFORMATION:
6237                 case SMB_SET_FILE_END_OF_FILE_INFO:
6238                 {
6239                         status = smb_set_file_end_of_file_info(conn, req,
6240                                                                 pdata,
6241                                                                 total_data,
6242                                                                 fsp,
6243                                                                 fname,
6244                                                                 &sbuf);
6245                         break;
6246                 }
6247
6248                 case SMB_FILE_DISPOSITION_INFORMATION:
6249                 case SMB_SET_FILE_DISPOSITION_INFO: /* Set delete on close for open file. */
6250                 {
6251 #if 0
6252                         /* JRA - We used to just ignore this on a path ?
6253                          * Shouldn't this be invalid level on a pathname
6254                          * based call ?
6255                          */
6256                         if (tran_call != TRANSACT2_SETFILEINFO) {
6257                                 return ERROR_NT(NT_STATUS_INVALID_LEVEL);
6258                         }
6259 #endif
6260                         status = smb_set_file_disposition_info(conn,
6261                                                 pdata,
6262                                                 total_data,
6263                                                 fsp,
6264                                                 fname,
6265                                                 &sbuf);
6266                         break;
6267                 }
6268
6269                 case SMB_FILE_POSITION_INFORMATION:
6270                 {
6271                         status = smb_file_position_information(conn,
6272                                                 pdata,
6273                                                 total_data,
6274                                                 fsp);
6275                         break;
6276                 }
6277
6278                 /* From tridge Samba4 :
6279                  * MODE_INFORMATION in setfileinfo (I have no
6280                  * idea what "mode information" on a file is - it takes a value of 0,
6281                  * 2, 4 or 6. What could it be?).
6282                  */
6283
6284                 case SMB_FILE_MODE_INFORMATION:
6285                 {
6286                         status = smb_file_mode_information(conn,
6287                                                 pdata,
6288                                                 total_data);
6289                         break;
6290                 }
6291
6292                 /*
6293                  * CIFS UNIX extensions.
6294                  */
6295
6296                 case SMB_SET_FILE_UNIX_BASIC:
6297                 {
6298                         status = smb_set_file_unix_basic(conn, req,
6299                                                         pdata,
6300                                                         total_data,
6301                                                         fsp,
6302                                                         fname,
6303                                                         &sbuf);
6304                         break;
6305                 }
6306
6307                 case SMB_SET_FILE_UNIX_INFO2:
6308                 {
6309                         status = smb_set_file_unix_info2(conn, req,
6310                                                         pdata,
6311                                                         total_data,
6312                                                         fsp,
6313                                                         fname,
6314                                                         &sbuf);
6315                         break;
6316                 }
6317
6318                 case SMB_SET_FILE_UNIX_LINK:
6319                 {
6320                         if (tran_call != TRANSACT2_SETPATHINFO) {
6321                                 /* We must have a pathname for this. */
6322                                 return ERROR_NT(NT_STATUS_INVALID_LEVEL);
6323                         }
6324                         status = smb_set_file_unix_link(conn, req, pdata,
6325                                                         total_data, fname);
6326                         break;
6327                 }
6328
6329                 case SMB_SET_FILE_UNIX_HLINK:
6330                 {
6331                         if (tran_call != TRANSACT2_SETPATHINFO) {
6332                                 /* We must have a pathname for this. */
6333                                 return ERROR_NT(NT_STATUS_INVALID_LEVEL);
6334                         }
6335                         status = smb_set_file_unix_hlink(conn, req,
6336                                                          pdata, total_data,
6337                                                          fname);
6338                         break;
6339                 }
6340
6341                 case SMB_FILE_RENAME_INFORMATION:
6342                 {
6343                         status = smb_file_rename_information(conn, req,
6344                                                              pdata, total_data,
6345                                                              fsp, fname);
6346                         break;
6347                 }
6348
6349 #if defined(HAVE_POSIX_ACLS)
6350                 case SMB_SET_POSIX_ACL:
6351                 {
6352                         status = smb_set_posix_acl(conn,
6353                                                 pdata,
6354                                                 total_data,
6355                                                 fsp,
6356                                                 fname,
6357                                                 &sbuf);
6358                         break;
6359                 }
6360 #endif
6361
6362                 case SMB_SET_POSIX_LOCK:
6363                 {
6364                         if (tran_call != TRANSACT2_SETFILEINFO) {
6365                                 return ERROR_NT(NT_STATUS_INVALID_LEVEL);
6366                         }
6367                         status = smb_set_posix_lock(conn,
6368                                                 inbuf,
6369                                                 length,
6370                                                 pdata,
6371                                                 total_data,
6372                                                 fsp);
6373                         break;
6374                 }
6375
6376                 case SMB_POSIX_PATH_OPEN:
6377                 {
6378                         if (tran_call != TRANSACT2_SETPATHINFO) {
6379                                 /* We must have a pathname for this. */
6380                                 return ERROR_NT(NT_STATUS_INVALID_LEVEL);
6381                         }
6382
6383                         status = smb_posix_open(conn, req,
6384                                                 ppdata,
6385                                                 total_data,
6386                                                 fname,
6387                                                 &sbuf,
6388                                                 &data_return_size);
6389                         break;
6390                 }
6391
6392                 case SMB_POSIX_PATH_UNLINK:
6393                 {
6394                         if (tran_call != TRANSACT2_SETPATHINFO) {
6395                                 /* We must have a pathname for this. */
6396                                 return ERROR_NT(NT_STATUS_INVALID_LEVEL);
6397                         }
6398
6399                         status = smb_posix_unlink(conn, req,
6400                                                 pdata,
6401                                                 total_data,
6402                                                 fname,
6403                                                 &sbuf);
6404                         break;
6405                 }
6406
6407                 default:
6408                         return ERROR_NT(NT_STATUS_INVALID_LEVEL);
6409         }
6410
6411
6412         if (!NT_STATUS_IS_OK(status)) {
6413                 if (open_was_deferred(req->mid)) {
6414                         /* We have re-scheduled this call. */
6415                         return -1;
6416                 }
6417                 if (blocking_lock_was_deferred(req->mid)) {
6418                         /* We have re-scheduled this call. */
6419                         return -1;
6420                 }
6421                 if (NT_STATUS_EQUAL(status,NT_STATUS_PATH_NOT_COVERED)) {
6422                         return ERROR_BOTH(NT_STATUS_PATH_NOT_COVERED, ERRSRV, ERRbadpath);
6423                 }
6424                 return ERROR_NT(status);
6425         }
6426
6427         SSVAL(params,0,0);
6428         send_trans2_replies(inbuf, outbuf, bufsize, params, 2, *ppdata, data_return_size, max_data_bytes);
6429
6430         return -1;
6431 }
6432
6433 /****************************************************************************
6434  Reply to a TRANS2_MKDIR (make directory with extended attributes).
6435 ****************************************************************************/
6436
6437 static void call_trans2mkdir(connection_struct *conn, struct smb_request *req,
6438                              char **pparams, int total_params,
6439                              char **ppdata, int total_data,
6440                              unsigned int max_data_bytes)
6441 {
6442         char *params = *pparams;
6443         char *pdata = *ppdata;
6444         pstring directory;
6445         SMB_STRUCT_STAT sbuf;
6446         NTSTATUS status = NT_STATUS_OK;
6447         struct ea_list *ea_list = NULL;
6448
6449         if (!CAN_WRITE(conn)) {
6450                 reply_doserror(req, ERRSRV, ERRaccess);
6451                 return;
6452         }
6453
6454         if (total_params < 5) {
6455                 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
6456                 return;
6457         }
6458
6459         srvstr_get_path(params, req->flags2, directory, &params[4],
6460                         sizeof(directory), total_params - 4, STR_TERMINATE,
6461                         &status);
6462         if (!NT_STATUS_IS_OK(status)) {
6463                 reply_nterror(req, status);
6464                 return;
6465         }
6466
6467         DEBUG(3,("call_trans2mkdir : name = %s\n", directory));
6468
6469         status = unix_convert(conn, directory, False, NULL, &sbuf);
6470         if (!NT_STATUS_IS_OK(status)) {
6471                 reply_nterror(req, status);
6472                 return;
6473         }
6474
6475         status = check_name(conn, directory);
6476         if (!NT_STATUS_IS_OK(status)) {
6477                 DEBUG(5,("call_trans2mkdir error (%s)\n", nt_errstr(status)));
6478                 reply_nterror(req, status);
6479                 return;
6480         }
6481
6482         /* Any data in this call is an EA list. */
6483         if (total_data && (total_data != 4) && !lp_ea_support(SNUM(conn))) {
6484                 reply_nterror(req, NT_STATUS_EAS_NOT_SUPPORTED);
6485                 return;
6486         }
6487
6488         /*
6489          * OS/2 workplace shell seems to send SET_EA requests of "null"
6490          * length (4 bytes containing IVAL 4).
6491          * They seem to have no effect. Bug #3212. JRA.
6492          */
6493
6494         if (total_data != 4) {
6495                 if (total_data < 10) {
6496                         reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
6497                         return;
6498                 }
6499
6500                 if (IVAL(pdata,0) > total_data) {
6501                         DEBUG(10,("call_trans2mkdir: bad total data size (%u) > %u\n",
6502                                 IVAL(pdata,0), (unsigned int)total_data));
6503                         reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
6504                         return;
6505                 }
6506
6507                 ea_list = read_ea_list(tmp_talloc_ctx(), pdata + 4,
6508                                        total_data - 4);
6509                 if (!ea_list) {
6510                         reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
6511                         return;
6512                 }
6513         } else if (IVAL(pdata,0) != 4) {
6514                 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
6515                 return;
6516         }
6517
6518         status = create_directory(conn, directory);
6519
6520         if (!NT_STATUS_IS_OK(status)) {
6521                 reply_nterror(req, status);
6522                 return;
6523         }
6524
6525         /* Try and set any given EA. */
6526         if (ea_list) {
6527                 status = set_ea(conn, NULL, directory, ea_list);
6528                 if (!NT_STATUS_IS_OK(status)) {
6529                         reply_nterror(req, status);
6530                         return;
6531                 }
6532         }
6533
6534         /* Realloc the parameter and data sizes */
6535         *pparams = (char *)SMB_REALLOC(*pparams,2);
6536         if(*pparams == NULL) {
6537                 reply_nterror(req, NT_STATUS_NO_MEMORY);
6538                 return;
6539         }
6540         params = *pparams;
6541
6542         SSVAL(params,0,0);
6543
6544         send_trans2_replies_new(req, params, 2, *ppdata, 0, max_data_bytes);
6545
6546         return;
6547 }
6548
6549 /****************************************************************************
6550  Reply to a TRANS2_FINDNOTIFYFIRST (start monitoring a directory for changes).
6551  We don't actually do this - we just send a null response.
6552 ****************************************************************************/
6553
6554 static void call_trans2findnotifyfirst(connection_struct *conn,
6555                                        struct smb_request *req,
6556                                        char **pparams, int total_params,
6557                                        char **ppdata, int total_data,
6558                                        unsigned int max_data_bytes)
6559 {
6560         static uint16 fnf_handle = 257;
6561         char *params = *pparams;
6562         uint16 info_level;
6563
6564         if (total_params < 6) {
6565                 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
6566                 return;
6567         }
6568
6569         info_level = SVAL(params,4);
6570         DEBUG(3,("call_trans2findnotifyfirst - info_level %d\n", info_level));
6571
6572         switch (info_level) {
6573                 case 1:
6574                 case 2:
6575                         break;
6576                 default:
6577                         reply_nterror(req, NT_STATUS_INVALID_LEVEL);
6578                         return;
6579         }
6580
6581         /* Realloc the parameter and data sizes */
6582         *pparams = (char *)SMB_REALLOC(*pparams,6);
6583         if (*pparams == NULL) {
6584                 reply_nterror(req, NT_STATUS_NO_MEMORY);
6585                 return;
6586         }
6587         params = *pparams;
6588
6589         SSVAL(params,0,fnf_handle);
6590         SSVAL(params,2,0); /* No changes */
6591         SSVAL(params,4,0); /* No EA errors */
6592
6593         fnf_handle++;
6594
6595         if(fnf_handle == 0)
6596                 fnf_handle = 257;
6597
6598         send_trans2_replies_new(req, params, 6, *ppdata, 0, max_data_bytes);
6599
6600         return;
6601 }
6602
6603 /****************************************************************************
6604  Reply to a TRANS2_FINDNOTIFYNEXT (continue monitoring a directory for
6605  changes). Currently this does nothing.
6606 ****************************************************************************/
6607
6608 static void call_trans2findnotifynext(connection_struct *conn,
6609                                       struct smb_request *req,
6610                                       char **pparams, int total_params,
6611                                       char **ppdata, int total_data,
6612                                       unsigned int max_data_bytes)
6613 {
6614         char *params = *pparams;
6615
6616         DEBUG(3,("call_trans2findnotifynext\n"));
6617
6618         /* Realloc the parameter and data sizes */
6619         *pparams = (char *)SMB_REALLOC(*pparams,4);
6620         if (*pparams == NULL) {
6621                 reply_nterror(req, NT_STATUS_NO_MEMORY);
6622                 return;
6623         }
6624         params = *pparams;
6625
6626         SSVAL(params,0,0); /* No changes */
6627         SSVAL(params,2,0); /* No EA errors */
6628
6629         send_trans2_replies_new(req, params, 4, *ppdata, 0, max_data_bytes);
6630
6631         return;
6632 }
6633
6634 /****************************************************************************
6635  Reply to a TRANS2_GET_DFS_REFERRAL - Shirish Kalele <kalele@veritas.com>.
6636 ****************************************************************************/
6637
6638 static int call_trans2getdfsreferral(connection_struct *conn, char* inbuf, char* outbuf, int length, int bufsize,
6639                                         char **pparams, int total_params, char **ppdata, int total_data,
6640                                         unsigned int max_data_bytes)
6641 {
6642         char *params = *pparams;
6643         pstring pathname;
6644         int reply_size = 0;
6645         int max_referral_level;
6646         NTSTATUS status = NT_STATUS_OK;
6647
6648         DEBUG(10,("call_trans2getdfsreferral\n"));
6649
6650         if (total_params < 3) {
6651                 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
6652         }
6653
6654         max_referral_level = SVAL(params,0);
6655
6656         if(!lp_host_msdfs())
6657                 return ERROR_DOS(ERRDOS,ERRbadfunc);
6658
6659         srvstr_pull(inbuf, SVAL(inbuf, smb_flg2), pathname, &params[2],
6660                     sizeof(pathname), total_params - 2, STR_TERMINATE);
6661         if((reply_size = setup_dfs_referral(conn, pathname,max_referral_level,ppdata,&status)) < 0)
6662                 return ERROR_NT(status);
6663
6664         SSVAL(outbuf,smb_flg2,SVAL(outbuf,smb_flg2) | FLAGS2_DFS_PATHNAMES);
6665         send_trans2_replies(inbuf, outbuf,bufsize,0,0,*ppdata,reply_size, max_data_bytes);
6666
6667         return(-1);
6668 }
6669
6670 #define LMCAT_SPL       0x53
6671 #define LMFUNC_GETJOBID 0x60
6672
6673 /****************************************************************************
6674  Reply to a TRANS2_IOCTL - used for OS/2 printing.
6675 ****************************************************************************/
6676
6677 static int call_trans2ioctl(connection_struct *conn, char* inbuf, char* outbuf, int length, int bufsize,
6678                                         char **pparams, int total_params, char **ppdata, int total_data,
6679                                         unsigned int max_data_bytes)
6680 {
6681         char *pdata = *ppdata;
6682         files_struct *fsp = file_fsp(SVAL(inbuf,smb_vwv15));
6683
6684         /* check for an invalid fid before proceeding */
6685
6686         if (!fsp)
6687                 return(ERROR_DOS(ERRDOS,ERRbadfid));
6688
6689         if ((SVAL(inbuf,(smb_setup+4)) == LMCAT_SPL) &&
6690                         (SVAL(inbuf,(smb_setup+6)) == LMFUNC_GETJOBID)) {
6691                 *ppdata = (char *)SMB_REALLOC(*ppdata, 32);
6692                 if (*ppdata == NULL) {
6693                         return ERROR_NT(NT_STATUS_NO_MEMORY);
6694                 }
6695                 pdata = *ppdata;
6696
6697                 /* NOTE - THIS IS ASCII ONLY AT THE MOMENT - NOT SURE IF OS/2
6698                         CAN ACCEPT THIS IN UNICODE. JRA. */
6699
6700                 SSVAL(pdata,0,fsp->rap_print_jobid);                     /* Job number */
6701                 srvstr_push( outbuf, SVAL(outbuf, smb_flg2), pdata + 2,
6702                              global_myname(), 15,
6703                              STR_ASCII|STR_TERMINATE); /* Our NetBIOS name */
6704                 srvstr_push( outbuf, SVAL(outbuf, smb_flg2), pdata+18,
6705                              lp_servicename(SNUM(conn)), 13,
6706                              STR_ASCII|STR_TERMINATE); /* Service name */
6707                 send_trans2_replies(inbuf, outbuf,bufsize,*pparams,0,*ppdata,32, max_data_bytes);
6708                 return(-1);
6709         } else {
6710                 DEBUG(2,("Unknown TRANS2_IOCTL\n"));
6711                 return ERROR_DOS(ERRSRV,ERRerror);
6712         }
6713 }
6714
6715 /****************************************************************************
6716  Reply to a SMBfindclose (stop trans2 directory search).
6717 ****************************************************************************/
6718
6719 int reply_findclose(connection_struct *conn,
6720                     char *inbuf,char *outbuf,int length,int bufsize)
6721 {
6722         int outsize = 0;
6723         int dptr_num=SVALS(inbuf,smb_vwv0);
6724         START_PROFILE(SMBfindclose);
6725
6726         DEBUG(3,("reply_findclose, dptr_num = %d\n", dptr_num));
6727
6728         dptr_close(&dptr_num);
6729
6730         outsize = set_message(inbuf, outbuf,0,0,False);
6731
6732         DEBUG(3,("SMBfindclose dptr_num = %d\n", dptr_num));
6733
6734         END_PROFILE(SMBfindclose);
6735         return(outsize);
6736 }
6737
6738 /****************************************************************************
6739  Reply to a SMBfindnclose (stop FINDNOTIFYFIRST directory search).
6740 ****************************************************************************/
6741
6742 int reply_findnclose(connection_struct *conn,
6743                      char *inbuf,char *outbuf,int length,int bufsize)
6744 {
6745         int outsize = 0;
6746         int dptr_num= -1;
6747         START_PROFILE(SMBfindnclose);
6748
6749         dptr_num = SVAL(inbuf,smb_vwv0);
6750
6751         DEBUG(3,("reply_findnclose, dptr_num = %d\n", dptr_num));
6752
6753         /* We never give out valid handles for a
6754            findnotifyfirst - so any dptr_num is ok here.
6755            Just ignore it. */
6756
6757         outsize = set_message(inbuf, outbuf,0,0,False);
6758
6759         DEBUG(3,("SMB_findnclose dptr_num = %d\n", dptr_num));
6760
6761         END_PROFILE(SMBfindnclose);
6762         return(outsize);
6763 }
6764
6765 static int handle_trans2(connection_struct *conn, struct smb_request *req,
6766                          struct trans_state *state,
6767                          char *inbuf, char *outbuf, int size, int bufsize)
6768 {
6769         int outsize = -1;
6770
6771         if (Protocol >= PROTOCOL_NT1) {
6772                 SSVAL(outbuf,smb_flg2,SVAL(outbuf,smb_flg2) | 0x40); /* IS_LONG_NAME */
6773         }
6774
6775         /* Now we must call the relevant TRANS2 function */
6776         switch(state->call)  {
6777         case TRANSACT2_OPEN:
6778         {
6779                 START_PROFILE(Trans2_open);
6780                 call_trans2open(conn, req,
6781                                 &state->param, state->total_param,
6782                                 &state->data, state->total_data,
6783                                 state->max_data_return);
6784                 END_PROFILE(Trans2_open);
6785                 break;
6786         }
6787
6788         case TRANSACT2_FINDFIRST:
6789         {
6790                 START_PROFILE(Trans2_findfirst);
6791                 call_trans2findfirst(conn, req,
6792                                      &state->param, state->total_param,
6793                                      &state->data, state->total_data,
6794                                      state->max_data_return);
6795                 END_PROFILE(Trans2_findfirst);
6796                 break;
6797         }
6798
6799         case TRANSACT2_FINDNEXT:
6800         {
6801                 START_PROFILE(Trans2_findnext);
6802                 call_trans2findnext(conn, req,
6803                                     &state->param, state->total_param,
6804                                     &state->data, state->total_data,
6805                                     state->max_data_return);
6806                 END_PROFILE(Trans2_findnext);
6807                 break;
6808         }
6809
6810         case TRANSACT2_QFSINFO:
6811         {
6812                 START_PROFILE(Trans2_qfsinfo);
6813                 outsize = call_trans2qfsinfo(
6814                         conn, inbuf, outbuf, size, bufsize,
6815                         &state->param, state->total_param,
6816                         &state->data, state->total_data,
6817                         state->max_data_return);
6818                 END_PROFILE(Trans2_qfsinfo);
6819             break;
6820         }
6821
6822         case TRANSACT2_SETFSINFO:
6823         {
6824                 START_PROFILE(Trans2_setfsinfo);
6825                 outsize = call_trans2setfsinfo(
6826                         conn, inbuf, outbuf, size, bufsize,
6827                         &state->param, state->total_param,
6828                         &state->data, state->total_data,
6829                         state->max_data_return);
6830                 END_PROFILE(Trans2_setfsinfo);
6831                 break;
6832         }
6833
6834         case TRANSACT2_QPATHINFO:
6835         case TRANSACT2_QFILEINFO:
6836         {
6837                 START_PROFILE(Trans2_qpathinfo);
6838                 call_trans2qfilepathinfo(conn, req, state->call,
6839                                          &state->param, state->total_param,
6840                                          &state->data, state->total_data,
6841                                          state->max_data_return);
6842                 END_PROFILE(Trans2_qpathinfo);
6843                 break;
6844         }
6845
6846         case TRANSACT2_SETPATHINFO:
6847         case TRANSACT2_SETFILEINFO:
6848         {
6849                 START_PROFILE(Trans2_setpathinfo);
6850                 outsize = call_trans2setfilepathinfo(
6851                         conn, req, inbuf, outbuf, size, bufsize, state->call,
6852                         &state->param, state->total_param,
6853                         &state->data, state->total_data,
6854                         state->max_data_return);
6855                 END_PROFILE(Trans2_setpathinfo);
6856                 break;
6857         }
6858
6859         case TRANSACT2_FINDNOTIFYFIRST:
6860         {
6861                 START_PROFILE(Trans2_findnotifyfirst);
6862                 call_trans2findnotifyfirst(conn, req,
6863                                            &state->param, state->total_param,
6864                                            &state->data, state->total_data,
6865                                            state->max_data_return);
6866                 END_PROFILE(Trans2_findnotifyfirst);
6867                 break;
6868         }
6869
6870         case TRANSACT2_FINDNOTIFYNEXT:
6871         {
6872                 START_PROFILE(Trans2_findnotifynext);
6873                 call_trans2findnotifynext(conn, req,
6874                                           &state->param, state->total_param,
6875                                           &state->data, state->total_data,
6876                                           state->max_data_return);
6877                 END_PROFILE(Trans2_findnotifynext);
6878                 break;
6879         }
6880
6881         case TRANSACT2_MKDIR:
6882         {
6883                 START_PROFILE(Trans2_mkdir);
6884                 call_trans2mkdir(conn, req,
6885                                  &state->param, state->total_param,
6886                                  &state->data, state->total_data,
6887                                  state->max_data_return);
6888                 END_PROFILE(Trans2_mkdir);
6889                 break;
6890         }
6891
6892         case TRANSACT2_GET_DFS_REFERRAL:
6893         {
6894                 START_PROFILE(Trans2_get_dfs_referral);
6895                 outsize = call_trans2getdfsreferral(
6896                         conn, inbuf, outbuf, size, bufsize,
6897                         &state->param, state->total_param,
6898                         &state->data, state->total_data,
6899                         state->max_data_return);
6900                 END_PROFILE(Trans2_get_dfs_referral);
6901                 break;
6902         }
6903
6904         case TRANSACT2_IOCTL:
6905         {
6906                 START_PROFILE(Trans2_ioctl);
6907                 outsize = call_trans2ioctl(
6908                         conn, inbuf, outbuf, size, bufsize,
6909                         &state->param, state->total_param,
6910                         &state->data, state->total_data,
6911                         state->max_data_return);
6912                 END_PROFILE(Trans2_ioctl);
6913                 break;
6914         }
6915
6916         default:
6917                 /* Error in request */
6918                 DEBUG(2,("Unknown request %d in trans2 call\n", state->call));
6919                 outsize = ERROR_DOS(ERRSRV,ERRerror);
6920         }
6921
6922         return outsize;
6923 }
6924
6925 /****************************************************************************
6926  Reply to a SMBtrans2.
6927  ****************************************************************************/
6928
6929 int reply_trans2(connection_struct *conn, char *inbuf,char *outbuf,
6930                  int size, int bufsize)
6931 {
6932         int outsize = 0;
6933         unsigned int dsoff = SVAL(inbuf, smb_dsoff);
6934         unsigned int dscnt = SVAL(inbuf, smb_dscnt);
6935         unsigned int psoff = SVAL(inbuf, smb_psoff);
6936         unsigned int pscnt = SVAL(inbuf, smb_pscnt);
6937         unsigned int tran_call = SVAL(inbuf, smb_setup0);
6938         struct trans_state *state;
6939         NTSTATUS result;
6940
6941         START_PROFILE(SMBtrans2);
6942
6943         result = allow_new_trans(conn->pending_trans, SVAL(inbuf, smb_mid));
6944         if (!NT_STATUS_IS_OK(result)) {
6945                 DEBUG(2, ("Got invalid trans2 request: %s\n",
6946                           nt_errstr(result)));
6947                 END_PROFILE(SMBtrans2);
6948                 return ERROR_NT(result);
6949         }
6950
6951         if (IS_IPC(conn) && (tran_call != TRANSACT2_OPEN)
6952             && (tran_call != TRANSACT2_GET_DFS_REFERRAL)
6953             && (tran_call != TRANSACT2_QFILEINFO)) {
6954                 END_PROFILE(SMBtrans2);
6955                 return ERROR_DOS(ERRSRV,ERRaccess);
6956         }
6957
6958         if ((state = TALLOC_P(conn->mem_ctx, struct trans_state)) == NULL) {
6959                 DEBUG(0, ("talloc failed\n"));
6960                 END_PROFILE(SMBtrans2);
6961                 return ERROR_NT(NT_STATUS_NO_MEMORY);
6962         }
6963
6964         state->cmd = SMBtrans2;
6965
6966         state->mid = SVAL(inbuf, smb_mid);
6967         state->vuid = SVAL(inbuf, smb_uid);
6968         state->setup_count = SVAL(inbuf, smb_suwcnt);
6969         state->setup = NULL;
6970         state->total_param = SVAL(inbuf, smb_tpscnt);
6971         state->param = NULL;
6972         state->total_data =  SVAL(inbuf, smb_tdscnt);
6973         state->data = NULL;
6974         state->max_param_return = SVAL(inbuf, smb_mprcnt);
6975         state->max_data_return  = SVAL(inbuf, smb_mdrcnt);
6976         state->max_setup_return = SVAL(inbuf, smb_msrcnt);
6977         state->close_on_completion = BITSETW(inbuf+smb_vwv5,0);
6978         state->one_way = BITSETW(inbuf+smb_vwv5,1);
6979
6980         state->call = tran_call;
6981
6982         /* All trans2 messages we handle have smb_sucnt == 1 - ensure this
6983            is so as a sanity check */
6984         if (state->setup_count != 1) {
6985                 /*
6986                  * Need to have rc=0 for ioctl to get job id for OS/2.
6987                  *  Network printing will fail if function is not successful.
6988                  *  Similar function in reply.c will be used if protocol
6989                  *  is LANMAN1.0 instead of LM1.2X002.
6990                  *  Until DosPrintSetJobInfo with PRJINFO3 is supported,
6991                  *  outbuf doesn't have to be set(only job id is used).
6992                  */
6993                 if ( (state->setup_count == 4) && (tran_call == TRANSACT2_IOCTL) &&
6994                                 (SVAL(inbuf,(smb_setup+4)) == LMCAT_SPL) &&
6995                                 (SVAL(inbuf,(smb_setup+6)) == LMFUNC_GETJOBID)) {
6996                         DEBUG(2,("Got Trans2 DevIOctl jobid\n"));
6997                 } else {
6998                         DEBUG(2,("Invalid smb_sucnt in trans2 call(%u)\n",state->setup_count));
6999                         DEBUG(2,("Transaction is %d\n",tran_call));
7000                         TALLOC_FREE(state);
7001                         END_PROFILE(SMBtrans2);
7002                         return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
7003                 }
7004         }
7005
7006         if ((dscnt > state->total_data) || (pscnt > state->total_param))
7007                 goto bad_param;
7008
7009         if (state->total_data) {
7010                 /* Can't use talloc here, the core routines do realloc on the
7011                  * params and data. */
7012                 state->data = (char *)SMB_MALLOC(state->total_data);
7013                 if (state->data == NULL) {
7014                         DEBUG(0,("reply_trans2: data malloc fail for %u "
7015                                  "bytes !\n", (unsigned int)state->total_data));
7016                         TALLOC_FREE(state);
7017                         END_PROFILE(SMBtrans2);
7018                         return(ERROR_DOS(ERRDOS,ERRnomem));
7019                 }
7020                 if ((dsoff+dscnt < dsoff) || (dsoff+dscnt < dscnt))
7021                         goto bad_param;
7022                 if ((smb_base(inbuf)+dsoff+dscnt > inbuf + size) ||
7023                     (smb_base(inbuf)+dsoff+dscnt < smb_base(inbuf)))
7024                         goto bad_param;
7025
7026                 memcpy(state->data,smb_base(inbuf)+dsoff,dscnt);
7027         }
7028
7029         if (state->total_param) {
7030                 /* Can't use talloc here, the core routines do realloc on the
7031                  * params and data. */
7032                 state->param = (char *)SMB_MALLOC(state->total_param);
7033                 if (state->param == NULL) {
7034                         DEBUG(0,("reply_trans: param malloc fail for %u "
7035                                  "bytes !\n", (unsigned int)state->total_param));
7036                         SAFE_FREE(state->data);
7037                         TALLOC_FREE(state);
7038                         END_PROFILE(SMBtrans2);
7039                         return(ERROR_DOS(ERRDOS,ERRnomem));
7040                 }
7041                 if ((psoff+pscnt < psoff) || (psoff+pscnt < pscnt))
7042                         goto bad_param;
7043                 if ((smb_base(inbuf)+psoff+pscnt > inbuf + size) ||
7044                     (smb_base(inbuf)+psoff+pscnt < smb_base(inbuf)))
7045                         goto bad_param;
7046
7047                 memcpy(state->param,smb_base(inbuf)+psoff,pscnt);
7048         }
7049
7050         state->received_data  = dscnt;
7051         state->received_param = pscnt;
7052
7053         if ((state->received_param == state->total_param) &&
7054             (state->received_data == state->total_data)) {
7055
7056                 struct smb_request *req;
7057
7058                 if (!(req = talloc(tmp_talloc_ctx(), struct smb_request))) {
7059                         END_PROFILE(SMBtrans2);
7060                         return ERROR_NT(NT_STATUS_NO_MEMORY);
7061                 }
7062
7063                 init_smb_request(req, (uint8 *)inbuf);
7064
7065                 outsize = handle_trans2(conn, req, state, inbuf, outbuf,
7066                                         size, bufsize);
7067                 if (req->outbuf != NULL) {
7068                         outsize = smb_len(req->outbuf) + 4;
7069                         memcpy(outbuf, req->outbuf, outsize);
7070                 }
7071                 TALLOC_FREE(req);
7072                 SAFE_FREE(state->data);
7073                 SAFE_FREE(state->param);
7074                 TALLOC_FREE(state);
7075                 END_PROFILE(SMBtrans2);
7076                 return outsize;
7077         }
7078
7079         DLIST_ADD(conn->pending_trans, state);
7080
7081         /* We need to send an interim response then receive the rest
7082            of the parameter/data bytes */
7083         outsize = set_message(inbuf, outbuf,0,0,False);
7084         show_msg(outbuf);
7085         END_PROFILE(SMBtrans2);
7086         return outsize;
7087
7088   bad_param:
7089
7090         DEBUG(0,("reply_trans2: invalid trans parameters\n"));
7091         SAFE_FREE(state->data);
7092         SAFE_FREE(state->param);
7093         TALLOC_FREE(state);
7094         END_PROFILE(SMBtrans2);
7095         return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
7096 }
7097
7098
7099 /****************************************************************************
7100  Reply to a SMBtranss2
7101  ****************************************************************************/
7102
7103 int reply_transs2(connection_struct *conn,
7104                   char *inbuf,char *outbuf,int size,int bufsize)
7105 {
7106         int outsize = 0;
7107         unsigned int pcnt,poff,dcnt,doff,pdisp,ddisp;
7108         struct trans_state *state;
7109         struct smb_request *req;
7110
7111         START_PROFILE(SMBtranss2);
7112
7113         show_msg(inbuf);
7114
7115         for (state = conn->pending_trans; state != NULL;
7116              state = state->next) {
7117                 if (state->mid == SVAL(inbuf,smb_mid)) {
7118                         break;
7119                 }
7120         }
7121
7122         if ((state == NULL) || (state->cmd != SMBtrans2)) {
7123                 END_PROFILE(SMBtranss2);
7124                 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
7125         }
7126
7127         /* Revise state->total_param and state->total_data in case they have
7128            changed downwards */
7129
7130         if (SVAL(inbuf, smb_tpscnt) < state->total_param)
7131                 state->total_param = SVAL(inbuf, smb_tpscnt);
7132         if (SVAL(inbuf, smb_tdscnt) < state->total_data)
7133                 state->total_data = SVAL(inbuf, smb_tdscnt);
7134
7135         pcnt = SVAL(inbuf, smb_spscnt);
7136         poff = SVAL(inbuf, smb_spsoff);
7137         pdisp = SVAL(inbuf, smb_spsdisp);
7138
7139         dcnt = SVAL(inbuf, smb_sdscnt);
7140         doff = SVAL(inbuf, smb_sdsoff);
7141         ddisp = SVAL(inbuf, smb_sdsdisp);
7142
7143         state->received_param += pcnt;
7144         state->received_data += dcnt;
7145
7146         if ((state->received_data > state->total_data) ||
7147             (state->received_param > state->total_param))
7148                 goto bad_param;
7149
7150         if (pcnt) {
7151                 if (pdisp+pcnt > state->total_param)
7152                         goto bad_param;
7153                 if ((pdisp+pcnt < pdisp) || (pdisp+pcnt < pcnt))
7154                         goto bad_param;
7155                 if (pdisp > state->total_param)
7156                         goto bad_param;
7157                 if ((smb_base(inbuf) + poff + pcnt > inbuf + size) ||
7158                     (smb_base(inbuf) + poff + pcnt < smb_base(inbuf)))
7159                         goto bad_param;
7160                 if (state->param + pdisp < state->param)
7161                         goto bad_param;
7162
7163                 memcpy(state->param+pdisp,smb_base(inbuf)+poff,
7164                        pcnt);
7165         }
7166
7167         if (dcnt) {
7168                 if (ddisp+dcnt > state->total_data)
7169                         goto bad_param;
7170                 if ((ddisp+dcnt < ddisp) || (ddisp+dcnt < dcnt))
7171                         goto bad_param;
7172                 if (ddisp > state->total_data)
7173                         goto bad_param;
7174                 if ((smb_base(inbuf) + doff + dcnt > inbuf + size) ||
7175                     (smb_base(inbuf) + doff + dcnt < smb_base(inbuf)))
7176                         goto bad_param;
7177                 if (state->data + ddisp < state->data)
7178                         goto bad_param;
7179
7180                 memcpy(state->data+ddisp, smb_base(inbuf)+doff,
7181                        dcnt);
7182         }
7183
7184         if ((state->received_param < state->total_param) ||
7185             (state->received_data < state->total_data)) {
7186                 END_PROFILE(SMBtranss2);
7187                 return -1;
7188         }
7189
7190         /* construct_reply_common has done us the favor to pre-fill the
7191          * command field with SMBtranss2 which is wrong :-)
7192          */
7193         SCVAL(outbuf,smb_com,SMBtrans2);
7194
7195         if (!(req = talloc(tmp_talloc_ctx(), struct smb_request))) {
7196                 END_PROFILE(SMBtranss2);
7197                 return ERROR_NT(NT_STATUS_NO_MEMORY);
7198         }
7199
7200         init_smb_request(req, (uint8 *)inbuf);
7201
7202         outsize = handle_trans2(conn, req, state, inbuf, outbuf, size,
7203                                 bufsize);
7204         if (req->outbuf != NULL) {
7205                 outsize = smb_len(req->outbuf) + 4;
7206                 memcpy(outbuf, req->outbuf, outsize);
7207         }
7208         TALLOC_FREE(req);
7209
7210         DLIST_REMOVE(conn->pending_trans, state);
7211         SAFE_FREE(state->data);
7212         SAFE_FREE(state->param);
7213         TALLOC_FREE(state);
7214
7215         if (outsize == 0) {
7216                 END_PROFILE(SMBtranss2);
7217                 return(ERROR_DOS(ERRSRV,ERRnosupport));
7218         }
7219
7220         END_PROFILE(SMBtranss2);
7221         return(outsize);
7222
7223   bad_param:
7224
7225         DEBUG(0,("reply_transs2: invalid trans parameters\n"));
7226         DLIST_REMOVE(conn->pending_trans, state);
7227         SAFE_FREE(state->data);
7228         SAFE_FREE(state->param);
7229         TALLOC_FREE(state);
7230         END_PROFILE(SMBtranss2);
7231         return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
7232 }