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                    2006-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 #include "ntioctl.h"
  28 #include "system/filesys.h"
  29 #include "version.h"
  30 #include "smbd/smbd.h"
  31 #include "smbd/globals.h"
  32 #include "../libcli/auth/libcli_auth.h"
  33 #include "../librpc/gen_ndr/xattr.h"
  34 #include "../librpc/gen_ndr/ndr_security.h"
  35 #include "../librpc/gen_ndr/open_files.h"
  36 #include "libcli/security/security.h"
  37 #include "trans2.h"
  38 #include "auth.h"
  39 #include "smbprofile.h"
  40 #include "rpc_server/srv_pipe_hnd.h"
  41 #include "printing.h"
  42 #include "lib/util_ea.h"
  43 #include "lib/readdir_attr.h"
  44
  45 #define DIR_ENTRY_SAFETY_MARGIN 4096
  46
  47 static char *store_file_unix_basic(connection_struct *conn,
  48                                 char *pdata,
  49                                 files_struct *fsp,
  50                                 const SMB_STRUCT_STAT *psbuf);
  51
  52 static char *store_file_unix_basic_info2(connection_struct *conn,
  53                                 char *pdata,
  54                                 files_struct *fsp,
  55                                 const SMB_STRUCT_STAT *psbuf);
  56
  57 /****************************************************************************
  58  Check if an open file handle or smb_fname is a symlink.
  59 ****************************************************************************/
  60
  61 static NTSTATUS refuse_symlink(connection_struct *conn,
  62                         const files_struct *fsp,
  63                         const struct smb_filename *smb_fname)
  64 {
  65         SMB_STRUCT_STAT sbuf;
  66         const SMB_STRUCT_STAT *pst = NULL;
  67
  68         if (fsp) {
  69                 pst = &fsp->fsp_name->st;
  70         } else {
  71                 pst = &smb_fname->st;
  72         }
  73
  74         if (!VALID_STAT(*pst)) {
  75                 int ret = vfs_stat_smb_basename(conn,
  76                                 smb_fname,
  77                                 &sbuf);
  78                 if (ret == -1 && errno != ENOENT) {
  79                         return map_nt_error_from_unix(errno);
  80                 } else if (ret == -1) {
  81                         /* it's not a symlink.. */
  82                         return NT_STATUS_OK;
  83                 }
  84                 pst = &sbuf;
  85         }
  86
  87         if (S_ISLNK(pst->st_ex_mode)) {
  88                 return NT_STATUS_ACCESS_DENIED;
  89         }
  90         return NT_STATUS_OK;
  91 }
  92
  93 NTSTATUS check_access_fsp(const struct files_struct *fsp,
  94                           uint32_t access_mask)
  95 {
  96         if (!(fsp->access_mask & access_mask)) {
  97                 return NT_STATUS_ACCESS_DENIED;
  98         }
  99         return NT_STATUS_OK;
 100 }
 101
 102 /********************************************************************
 103  The canonical "check access" based on object handle or path function.
 104 ********************************************************************/
 105
 106 NTSTATUS check_access(connection_struct *conn,
 107                                 files_struct *fsp,
 108                                 const struct smb_filename *smb_fname,
 109                                 uint32_t access_mask)
 110 {
 111         NTSTATUS status;
 112
 113         if (fsp) {
 114                 status = check_access_fsp(fsp, access_mask);
 115         } else {
 116                 status = smbd_check_access_rights(conn, smb_fname,
 117                                                   false, access_mask);
 118         }
 119
 120         return status;
 121 }
 122
 123 /********************************************************************
 124  Roundup a value to the nearest allocation roundup size boundary.
 125  Only do this for Windows clients.
 126 ********************************************************************/
 127
 128 uint64_t smb_roundup(connection_struct *conn, uint64_t val)
 129 {
 130         uint64_t rval = lp_allocation_roundup_size(SNUM(conn));
 131
 132         /* Only roundup for Windows clients. */
 133         enum remote_arch_types ra_type = get_remote_arch();
 134         if (rval && (ra_type != RA_SAMBA) && (ra_type != RA_CIFSFS)) {
 135                 val = SMB_ROUNDUP(val,rval);
 136         }
 137         return val;
 138 }
 139
 140 /********************************************************************
 141  Create a 64 bit FileIndex. If the file is on the same device as
 142  the root of the share, just return the 64-bit inode. If it isn't,
 143  mangle as we used to do.
 144 ********************************************************************/
 145
 146 uint64_t get_FileIndex(connection_struct *conn, const SMB_STRUCT_STAT *psbuf)
 147 {
 148         uint64_t file_index;
 149         if (conn->sconn->aapl_zero_file_id) {
 150                 return 0;
 151         }
 152         if (conn->base_share_dev == psbuf->st_ex_dev) {
 153                 return (uint64_t)psbuf->st_ex_ino;
 154         }
 155         file_index = ((psbuf->st_ex_ino) & UINT32_MAX); /* FileIndexLow */
 156         file_index |= ((uint64_t)((psbuf->st_ex_dev) & UINT32_MAX)) << 32; /* FileIndexHigh */
 157         return file_index;
 158 }
 159
 160
 161 /********************************************************************
 162  Globally (for this connection / multi-channel) disable file-ID
 163  calculation. This is required to be global because it serves
 164  Macs in AAPL mode, which is globally set.
 165 ********************************************************************/
 166 void aapl_force_zero_file_id(struct smbd_server_connection *sconn)
 167 {
 168         sconn->aapl_zero_file_id = true;
 169 }
 170
 171 /****************************************************************************
 172  Utility functions for dealing with extended attributes.
 173 ****************************************************************************/
 174
 175 /****************************************************************************
 176  Refuse to allow clients to overwrite our private xattrs.
 177 ****************************************************************************/
 178
 179 bool samba_private_attr_name(const char *unix_ea_name)
 180 {
 181         static const char * const prohibited_ea_names[] = {
 182                 SAMBA_POSIX_INHERITANCE_EA_NAME,
 183                 SAMBA_XATTR_DOS_ATTRIB,
 184                 SAMBA_XATTR_MARKER,
 185                 XATTR_NTACL_NAME,
 186                 NULL
 187         };
 188
 189         int i;
 190
 191         for (i = 0; prohibited_ea_names[i]; i++) {
 192                 if (strequal( prohibited_ea_names[i], unix_ea_name))
 193                         return true;
 194         }
 195         if (strncasecmp_m(unix_ea_name, SAMBA_XATTR_DOSSTREAM_PREFIX,
 196                         strlen(SAMBA_XATTR_DOSSTREAM_PREFIX)) == 0) {
 197                 return true;
 198         }
 199         return false;
 200 }
 201
 202 /****************************************************************************
 203  Get one EA value. Fill in a struct ea_struct.
 204 ****************************************************************************/
 205
 206 NTSTATUS get_ea_value(TALLOC_CTX *mem_ctx,
 207                         connection_struct *conn,
 208                         files_struct *fsp,
 209                         const struct smb_filename *smb_fname,
 210                         const char *ea_name,
 211                         struct ea_struct *pea)
 212 {
 213         /* Get the value of this xattr. Max size is 64k. */
 214         size_t attr_size = 256;
 215         char *val = NULL;
 216         ssize_t sizeret;
 217
 218  again:
 219
 220         val = talloc_realloc(mem_ctx, val, char, attr_size);
 221         if (!val) {
 222                 return NT_STATUS_NO_MEMORY;
 223         }
 224
 225         if (fsp && fsp->fh->fd != -1) {
 226                 sizeret = SMB_VFS_FGETXATTR(fsp, ea_name, val, attr_size);
 227         } else {
 228                 sizeret = SMB_VFS_GETXATTR(conn, smb_fname,
 229                                 ea_name, val, attr_size);
 230         }
 231
 232         if (sizeret == -1 && errno == ERANGE && attr_size != 65536) {
 233                 attr_size = 65536;
 234                 goto again;
 235         }
 236
 237         if (sizeret == -1) {
 238                 return map_nt_error_from_unix(errno);
 239         }
 240
 241         DEBUG(10,("get_ea_value: EA %s is of length %u\n", ea_name, (unsigned int)sizeret));
 242         dump_data(10, (uint8_t *)val, sizeret);
 243
 244         pea->flags = 0;
 245         if (strnequal(ea_name, "user.", 5)) {
 246                 pea->name = talloc_strdup(mem_ctx, &ea_name[5]);
 247         } else {
 248                 pea->name = talloc_strdup(mem_ctx, ea_name);
 249         }
 250         if (pea->name == NULL) {
 251                 TALLOC_FREE(val);
 252                 return NT_STATUS_NO_MEMORY;
 253         }
 254         pea->value.data = (unsigned char *)val;
 255         pea->value.length = (size_t)sizeret;
 256         return NT_STATUS_OK;
 257 }
 258
 259 NTSTATUS get_ea_names_from_file(TALLOC_CTX *mem_ctx,
 260                                 connection_struct *conn,
 261                                 files_struct *fsp,
 262                                 const struct smb_filename *smb_fname,
 263                                 char ***pnames,
 264                                 size_t *pnum_names)
 265 {
 266         char smallbuf[1024];
 267         /* Get a list of all xattrs. Max namesize is 64k. */
 268         size_t ea_namelist_size = 1024;
 269         char *ea_namelist = smallbuf;
 270         char *to_free = NULL;
 271
 272         char *p;
 273         char **names;
 274         size_t num_names;
 275         ssize_t sizeret = -1;
 276         NTSTATUS status;
 277
 278         if (pnames) {
 279                 *pnames = NULL;
 280         }
 281         *pnum_names = 0;
 282
 283         status = refuse_symlink(conn, fsp, smb_fname);
 284         if (!NT_STATUS_IS_OK(status)) {
 285                 /*
 286                  * Just return no EA's on a symlink.
 287                  */
 288                 return NT_STATUS_OK;
 289         }
 290
 291         if (fsp && fsp->fh->fd != -1) {
 292                 sizeret = SMB_VFS_FLISTXATTR(fsp, ea_namelist,
 293                                              ea_namelist_size);
 294         } else {
 295                 sizeret = SMB_VFS_LISTXATTR(conn,
 296                                             smb_fname,
 297                                             ea_namelist,
 298                                             ea_namelist_size);
 299         }
 300
 301         if ((sizeret == -1) && (errno == ERANGE)) {
 302                 ea_namelist_size = 65536;
 303                 ea_namelist = talloc_array(mem_ctx, char, ea_namelist_size);
 304                 if (ea_namelist == NULL) {
 305                         return NT_STATUS_NO_MEMORY;
 306                 }
 307                 to_free = ea_namelist;
 308
 309                 if (fsp && fsp->fh->fd != -1) {
 310                         sizeret = SMB_VFS_FLISTXATTR(fsp, ea_namelist,
 311                                                      ea_namelist_size);
 312                 } else {
 313                         sizeret = SMB_VFS_LISTXATTR(conn,
 314                                                     smb_fname,
 315                                                     ea_namelist,
 316                                                     ea_namelist_size);
 317                 }
 318         }
 319
 320         if (sizeret == -1) {
 321                 status = map_nt_error_from_unix(errno);
 322                 TALLOC_FREE(to_free);
 323                 return status;
 324         }
 325
 326         DBG_DEBUG("ea_namelist size = %zd\n", sizeret);
 327
 328         if (sizeret == 0) {
 329                 TALLOC_FREE(to_free);
 330                 return NT_STATUS_OK;
 331         }
 332
 333         /*
 334          * Ensure the result is 0-terminated
 335          */
 336
 337         if (ea_namelist[sizeret-1] != '\0') {
 338                 TALLOC_FREE(to_free);
 339                 return NT_STATUS_INTERNAL_ERROR;
 340         }
 341
 342         /*
 343          * count the names
 344          */
 345         num_names = 0;
 346
 347         for (p = ea_namelist; p - ea_namelist < sizeret; p += strlen(p)+1) {
 348                 num_names += 1;
 349         }
 350
 351         *pnum_names = num_names;
 352
 353         if (pnames == NULL) {
 354                 TALLOC_FREE(to_free);
 355                 return NT_STATUS_OK;
 356         }
 357
 358         names = talloc_array(mem_ctx, char *, num_names);
 359         if (names == NULL) {
 360                 DEBUG(0, ("talloc failed\n"));
 361                 TALLOC_FREE(to_free);
 362                 return NT_STATUS_NO_MEMORY;
 363         }
 364
 365         if (ea_namelist == smallbuf) {
 366                 ea_namelist = talloc_memdup(names, smallbuf, sizeret);
 367                 if (ea_namelist == NULL) {
 368                         TALLOC_FREE(names);
 369                         return NT_STATUS_NO_MEMORY;
 370                 }
 371         } else {
 372                 talloc_steal(names, ea_namelist);
 373
 374                 ea_namelist = talloc_realloc(names, ea_namelist, char,
 375                                              sizeret);
 376                 if (ea_namelist == NULL) {
 377                         TALLOC_FREE(names);
 378                         return NT_STATUS_NO_MEMORY;
 379                 }
 380         }
 381
 382         num_names = 0;
 383
 384         for (p = ea_namelist; p - ea_namelist < sizeret; p += strlen(p)+1) {
 385                 names[num_names++] = p;
 386         }
 387
 388         *pnames = names;
 389
 390         return NT_STATUS_OK;
 391 }
 392
 393 /****************************************************************************
 394  Return a linked list of the total EA's. Plus the total size
 395 ****************************************************************************/
 396
 397 static NTSTATUS get_ea_list_from_file_path(TALLOC_CTX *mem_ctx,
 398                                 connection_struct *conn,
 399                                 files_struct *fsp,
 400                                 const struct smb_filename *smb_fname,
 401                                 size_t *pea_total_len,
 402                                 struct ea_list **ea_list)
 403 {
 404         /* Get a list of all xattrs. Max namesize is 64k. */
 405         size_t i, num_names;
 406         char **names;
 407         struct ea_list *ea_list_head = NULL;
 408         bool posix_pathnames = false;
 409         NTSTATUS status;
 410
 411         *pea_total_len = 0;
 412         *ea_list = NULL;
 413
 414         if (!lp_ea_support(SNUM(conn))) {
 415                 return NT_STATUS_OK;
 416         }
 417
 418         if (fsp) {
 419                 posix_pathnames =
 420                         (fsp->fsp_name->flags & SMB_FILENAME_POSIX_PATH);
 421         } else {
 422                 posix_pathnames = (smb_fname->flags & SMB_FILENAME_POSIX_PATH);
 423         }
 424
 425         status = get_ea_names_from_file(talloc_tos(),
 426                                 conn,
 427                                 fsp,
 428                                 smb_fname,
 429                                 &names,
 430                                 &num_names);
 431
 432         if (!NT_STATUS_IS_OK(status)) {
 433                 return status;
 434         }
 435
 436         if (num_names == 0) {
 437                 return NT_STATUS_OK;
 438         }
 439
 440         for (i=0; i<num_names; i++) {
 441                 struct ea_list *listp;
 442                 fstring dos_ea_name;
 443
 444                 if (strnequal(names[i], "system.", 7)
 445                     || samba_private_attr_name(names[i]))
 446                         continue;
 447
 448                 /*
 449                  * Filter out any underlying POSIX EA names
 450                  * that a Windows client can't handle.
 451                  */
 452                 if (!posix_pathnames &&
 453                                 is_invalid_windows_ea_name(names[i])) {
 454                         continue;
 455                 }
 456
 457                 listp = talloc(mem_ctx, struct ea_list);
 458                 if (listp == NULL) {
 459                         return NT_STATUS_NO_MEMORY;
 460                 }
 461
 462                 status = get_ea_value(listp,
 463                                         conn,
 464                                         fsp,
 465                                         smb_fname,
 466                                         names[i],
 467                                         &listp->ea);
 468
 469                 if (!NT_STATUS_IS_OK(status)) {
 470                         TALLOC_FREE(listp);
 471                         return status;
 472                 }
 473
 474                 if (listp->ea.value.length == 0) {
 475                         /*
 476                          * We can never return a zero length EA.
 477                          * Windows reports the EA's as corrupted.
 478                          */
 479                         TALLOC_FREE(listp);
 480                         continue;
 481                 }
 482
 483                 push_ascii_fstring(dos_ea_name, listp->ea.name);
 484
 485                 *pea_total_len +=
 486                         4 + strlen(dos_ea_name) + 1 + listp->ea.value.length;
 487
 488                 DEBUG(10,("get_ea_list_from_file: total_len = %u, %s, val len "
 489                           "= %u\n", (unsigned int)*pea_total_len, dos_ea_name,
 490                           (unsigned int)listp->ea.value.length));
 491
 492                 DLIST_ADD_END(ea_list_head, listp);
 493
 494         }
 495
 496         /* Add on 4 for total length. */
 497         if (*pea_total_len) {
 498                 *pea_total_len += 4;
 499         }
 500
 501         DEBUG(10, ("get_ea_list_from_file: total_len = %u\n",
 502                    (unsigned int)*pea_total_len));
 503
 504         *ea_list = ea_list_head;
 505         return NT_STATUS_OK;
 506 }
 507
 508 static NTSTATUS get_ea_list_from_file(TALLOC_CTX *mem_ctx, connection_struct *conn, files_struct *fsp,
 509                                       const struct smb_filename *smb_fname, size_t *pea_total_len, struct ea_list **ea_list)
 510 {
 511         *pea_total_len = 0;
 512         *ea_list = NULL;
 513
 514         if (!lp_ea_support(SNUM(conn))) {
 515                 return NT_STATUS_OK;
 516         }
 517
 518         if (is_ntfs_stream_smb_fname(smb_fname)) {
 519                 return NT_STATUS_INVALID_PARAMETER;
 520         }
 521
 522         return get_ea_list_from_file_path(mem_ctx,
 523                                 conn,
 524                                 fsp,
 525                                 smb_fname,
 526                                 pea_total_len,
 527                                 ea_list);
 528 }
 529
 530 /****************************************************************************
 531  Fill a qfilepathinfo buffer with EA's. Returns the length of the buffer
 532  that was filled.
 533 ****************************************************************************/
 534
 535 static unsigned int fill_ea_buffer(TALLOC_CTX *mem_ctx, char *pdata, unsigned int total_data_size,
 536         connection_struct *conn, struct ea_list *ea_list)
 537 {
 538         unsigned int ret_data_size = 4;
 539         char *p = pdata;
 540
 541         SMB_ASSERT(total_data_size >= 4);
 542
 543         if (!lp_ea_support(SNUM(conn))) {
 544                 SIVAL(pdata,4,0);
 545                 return 4;
 546         }
 547
 548         for (p = pdata + 4; ea_list; ea_list = ea_list->next) {
 549                 size_t dos_namelen;
 550                 fstring dos_ea_name;
 551                 push_ascii_fstring(dos_ea_name, ea_list->ea.name);
 552                 dos_namelen = strlen(dos_ea_name);
 553                 if (dos_namelen > 255 || dos_namelen == 0) {
 554                         break;
 555                 }
 556                 if (ea_list->ea.value.length > 65535) {
 557                         break;
 558                 }
 559                 if (4 + dos_namelen + 1 + ea_list->ea.value.length > total_data_size) {
 560                         break;
 561                 }
 562
 563                 /* We know we have room. */
 564                 SCVAL(p,0,ea_list->ea.flags);
 565                 SCVAL(p,1,dos_namelen);
 566                 SSVAL(p,2,ea_list->ea.value.length);
 567                 strlcpy(p+4, dos_ea_name, dos_namelen+1);
 568                 memcpy( p + 4 + dos_namelen + 1, ea_list->ea.value.data, ea_list->ea.value.length);
 569
 570                 total_data_size -= 4 + dos_namelen + 1 + ea_list->ea.value.length;
 571                 p += 4 + dos_namelen + 1 + ea_list->ea.value.length;
 572         }
 573
 574         ret_data_size = PTR_DIFF(p, pdata);
 575         DEBUG(10,("fill_ea_buffer: data_size = %u\n", ret_data_size ));
 576         SIVAL(pdata,0,ret_data_size);
 577         return ret_data_size;
 578 }
 579
 580 static NTSTATUS fill_ea_chained_buffer(TALLOC_CTX *mem_ctx,
 581                                        char *pdata,
 582                                        unsigned int total_data_size,
 583                                        unsigned int *ret_data_size,
 584                                        connection_struct *conn,
 585                                        struct ea_list *ea_list)
 586 {
 587         uint8_t *p = (uint8_t *)pdata;
 588         uint8_t *last_start = NULL;
 589         bool do_store_data = (pdata != NULL);
 590
 591         *ret_data_size = 0;
 592
 593         if (!lp_ea_support(SNUM(conn))) {
 594                 return NT_STATUS_NO_EAS_ON_FILE;
 595         }
 596
 597         for (; ea_list; ea_list = ea_list->next) {
 598                 size_t dos_namelen;
 599                 fstring dos_ea_name;
 600                 size_t this_size;
 601                 size_t pad = 0;
 602
 603                 if (last_start != NULL && do_store_data) {
 604                         SIVAL(last_start, 0, PTR_DIFF(p, last_start));
 605                 }
 606                 last_start = p;
 607
 608                 push_ascii_fstring(dos_ea_name, ea_list->ea.name);
 609                 dos_namelen = strlen(dos_ea_name);
 610                 if (dos_namelen > 255 || dos_namelen == 0) {
 611                         return NT_STATUS_INTERNAL_ERROR;
 612                 }
 613                 if (ea_list->ea.value.length > 65535) {
 614                         return NT_STATUS_INTERNAL_ERROR;
 615                 }
 616
 617                 this_size = 0x08 + dos_namelen + 1 + ea_list->ea.value.length;
 618
 619                 if (ea_list->next) {
 620                         pad = (4 - (this_size % 4)) % 4;
 621                         this_size += pad;
 622                 }
 623
 624                 if (do_store_data) {
 625                         if (this_size > total_data_size) {
 626                                 return NT_STATUS_INFO_LENGTH_MISMATCH;
 627                         }
 628
 629                         /* We know we have room. */
 630                         SIVAL(p, 0x00, 0); /* next offset */
 631                         SCVAL(p, 0x04, ea_list->ea.flags);
 632                         SCVAL(p, 0x05, dos_namelen);
 633                         SSVAL(p, 0x06, ea_list->ea.value.length);
 634                         strlcpy((char *)(p+0x08), dos_ea_name, dos_namelen+1);
 635                         memcpy(p + 0x08 + dos_namelen + 1, ea_list->ea.value.data, ea_list->ea.value.length);
 636                         if (pad) {
 637                                 memset(p + 0x08 + dos_namelen + 1 + ea_list->ea.value.length,
 638                                         '\0',
 639                                         pad);
 640                         }
 641                         total_data_size -= this_size;
 642                 }
 643
 644                 p += this_size;
 645         }
 646
 647         *ret_data_size = PTR_DIFF(p, pdata);
 648         DEBUG(10,("fill_ea_chained_buffer: data_size = %u\n", *ret_data_size));
 649         return NT_STATUS_OK;
 650 }
 651
 652 static unsigned int estimate_ea_size(connection_struct *conn, files_struct *fsp, const struct smb_filename *smb_fname)
 653 {
 654         size_t total_ea_len = 0;
 655         TALLOC_CTX *mem_ctx;
 656         struct ea_list *ea_list = NULL;
 657
 658         if (!lp_ea_support(SNUM(conn))) {
 659                 return 0;
 660         }
 661         mem_ctx = talloc_stackframe();
 662
 663         /* If this is a stream fsp, then we need to instead find the
 664          * estimated ea len from the main file, not the stream
 665          * (streams cannot have EAs), but the estimate isn't just 0 in
 666          * this case! */
 667         if (is_ntfs_stream_smb_fname(smb_fname)) {
 668                 fsp = NULL;
 669         }
 670         (void)get_ea_list_from_file_path(mem_ctx,
 671                                 conn,
 672                                 fsp,
 673                                 smb_fname,
 674                                 &total_ea_len,
 675                                 &ea_list);
 676         if(conn->sconn->using_smb2) {
 677                 NTSTATUS status;
 678                 unsigned int ret_data_size;
 679                 /*
 680                  * We're going to be using fill_ea_chained_buffer() to
 681                  * marshall EA's - this size is significantly larger
 682                  * than the SMB1 buffer. Re-calculate the size without
 683                  * marshalling.
 684                  */
 685                 status = fill_ea_chained_buffer(mem_ctx,
 686                                                 NULL,
 687                                                 0,
 688                                                 &ret_data_size,
 689                                                 conn,
 690                                                 ea_list);
 691                 if (!NT_STATUS_IS_OK(status)) {
 692                         ret_data_size = 0;
 693                 }
 694                 total_ea_len = ret_data_size;
 695         }
 696         TALLOC_FREE(mem_ctx);
 697         return total_ea_len;
 698 }
 699
 700 /****************************************************************************
 701  Ensure the EA name is case insensitive by matching any existing EA name.
 702 ****************************************************************************/
 703
 704 static void canonicalize_ea_name(connection_struct *conn,
 705                         files_struct *fsp,
 706                         const struct smb_filename *smb_fname,
 707                         fstring unix_ea_name)
 708 {
 709         size_t total_ea_len;
 710         TALLOC_CTX *mem_ctx = talloc_tos();
 711         struct ea_list *ea_list;
 712         NTSTATUS status = get_ea_list_from_file_path(mem_ctx,
 713                                         conn,
 714                                         fsp,
 715                                         smb_fname,
 716                                         &total_ea_len,
 717                                         &ea_list);
 718         if (!NT_STATUS_IS_OK(status)) {
 719                 return;
 720         }
 721
 722         for (; ea_list; ea_list = ea_list->next) {
 723                 if (strequal(&unix_ea_name[5], ea_list->ea.name)) {
 724                         DEBUG(10,("canonicalize_ea_name: %s -> %s\n",
 725                                 &unix_ea_name[5], ea_list->ea.name));
 726                         strlcpy(&unix_ea_name[5], ea_list->ea.name, sizeof(fstring)-5);
 727                         break;
 728                 }
 729         }
 730 }
 731
 732 /****************************************************************************
 733  Set or delete an extended attribute.
 734 ****************************************************************************/
 735
 736 NTSTATUS set_ea(connection_struct *conn, files_struct *fsp,
 737                 const struct smb_filename *smb_fname, struct ea_list *ea_list)
 738 {
 739         NTSTATUS status;
 740         bool posix_pathnames = false;
 741
 742         if (!lp_ea_support(SNUM(conn))) {
 743                 return NT_STATUS_EAS_NOT_SUPPORTED;
 744         }
 745
 746         if (fsp) {
 747                 posix_pathnames =
 748                         (fsp->fsp_name->flags & SMB_FILENAME_POSIX_PATH);
 749         } else {
 750                 posix_pathnames = (smb_fname->flags & SMB_FILENAME_POSIX_PATH);
 751         }
 752
 753         status = refuse_symlink(conn, fsp, smb_fname);
 754         if (!NT_STATUS_IS_OK(status)) {
 755                 return status;
 756         }
 757
 758         status = check_access(conn, fsp, smb_fname, FILE_WRITE_EA);
 759         if (!NT_STATUS_IS_OK(status)) {
 760                 return status;
 761         }
 762
 763         /* Setting EAs on streams isn't supported. */
 764         if (is_ntfs_stream_smb_fname(smb_fname)) {
 765                 return NT_STATUS_INVALID_PARAMETER;
 766         }
 767
 768         /*
 769          * Filter out invalid Windows EA names - before
 770          * we set *any* of them.
 771          */
 772
 773         if (!posix_pathnames && ea_list_has_invalid_name(ea_list)) {
 774                 return STATUS_INVALID_EA_NAME;
 775         }
 776
 777         for (;ea_list; ea_list = ea_list->next) {
 778                 int ret;
 779                 fstring unix_ea_name;
 780
 781                 fstrcpy(unix_ea_name, "user."); /* All EA's must start with user. */
 782                 fstrcat(unix_ea_name, ea_list->ea.name);
 783
 784                 canonicalize_ea_name(conn,
 785                                 fsp,
 786                                 smb_fname,
 787                                 unix_ea_name);
 788
 789                 DEBUG(10,("set_ea: ea_name %s ealen = %u\n", unix_ea_name, (unsigned int)ea_list->ea.value.length));
 790
 791                 if (samba_private_attr_name(unix_ea_name)) {
 792                         DEBUG(10,("set_ea: ea name %s is a private Samba name.\n", unix_ea_name));
 793                         return NT_STATUS_ACCESS_DENIED;
 794                 }
 795
 796                 if (ea_list->ea.value.length == 0) {
 797                         /* Remove the attribute. */
 798                         if (fsp && (fsp->fh->fd != -1)) {
 799                                 DEBUG(10,("set_ea: deleting ea name %s on "
 800                                           "file %s by file descriptor.\n",
 801                                           unix_ea_name, fsp_str_dbg(fsp)));
 802                                 ret = SMB_VFS_FREMOVEXATTR(fsp, unix_ea_name);
 803                         } else {
 804                                 DEBUG(10,("set_ea: deleting ea name %s on file %s.\n",
 805                                         unix_ea_name, smb_fname->base_name));
 806                                 ret = SMB_VFS_REMOVEXATTR(conn,
 807                                                 smb_fname,
 808                                                 unix_ea_name);
 809                         }
 810 #ifdef ENOATTR
 811                         /* Removing a non existent attribute always succeeds. */
 812                         if (ret == -1 && errno == ENOATTR) {
 813                                 DEBUG(10,("set_ea: deleting ea name %s didn't exist - succeeding by default.\n",
 814                                                 unix_ea_name));
 815                                 ret = 0;
 816                         }
 817 #endif
 818                 } else {
 819                         if (fsp && (fsp->fh->fd != -1)) {
 820                                 DEBUG(10,("set_ea: setting ea name %s on file "
 821                                           "%s by file descriptor.\n",
 822                                           unix_ea_name, fsp_str_dbg(fsp)));
 823                                 ret = SMB_VFS_FSETXATTR(fsp, unix_ea_name,
 824                                                         ea_list->ea.value.data, ea_list->ea.value.length, 0);
 825                         } else {
 826                                 DEBUG(10,("set_ea: setting ea name %s on file %s.\n",
 827                                         unix_ea_name, smb_fname->base_name));
 828                                 ret = SMB_VFS_SETXATTR(conn,
 829                                                 smb_fname,
 830                                                 unix_ea_name,
 831                                                 ea_list->ea.value.data,
 832                                                 ea_list->ea.value.length,
 833                                                 0);
 834                         }
 835                 }
 836
 837                 if (ret == -1) {
 838 #ifdef ENOTSUP
 839                         if (errno == ENOTSUP) {
 840                                 return NT_STATUS_EAS_NOT_SUPPORTED;
 841                         }
 842 #endif
 843                         return map_nt_error_from_unix(errno);
 844                 }
 845
 846         }
 847         return NT_STATUS_OK;
 848 }
 849 /****************************************************************************
 850  Read a list of EA names from an incoming data buffer. Create an ea_list with them.
 851 ****************************************************************************/
 852
 853 static struct ea_list *read_ea_name_list(TALLOC_CTX *ctx, const char *pdata, size_t data_size)
 854 {
 855         struct ea_list *ea_list_head = NULL;
 856         size_t converted_size, offset = 0;
 857
 858         while (offset + 2 < data_size) {
 859                 struct ea_list *eal = talloc_zero(ctx, struct ea_list);
 860                 unsigned int namelen = CVAL(pdata,offset);
 861
 862                 offset++; /* Go past the namelen byte. */
 863
 864                 /* integer wrap paranioa. */
 865                 if ((offset + namelen < offset) || (offset + namelen < namelen) ||
 866                                 (offset > data_size) || (namelen > data_size) ||
 867                                 (offset + namelen >= data_size)) {
 868                         break;
 869                 }
 870                 /* Ensure the name is null terminated. */
 871                 if (pdata[offset + namelen] != '\0') {
 872                         return NULL;
 873                 }
 874                 if (!pull_ascii_talloc(ctx, &eal->ea.name, &pdata[offset],
 875                                        &converted_size)) {
 876                         DEBUG(0,("read_ea_name_list: pull_ascii_talloc "
 877                                  "failed: %s", strerror(errno)));
 878                 }
 879                 if (!eal->ea.name) {
 880                         return NULL;
 881                 }
 882
 883                 offset += (namelen + 1); /* Go past the name + terminating zero. */
 884                 DLIST_ADD_END(ea_list_head, eal);
 885                 DEBUG(10,("read_ea_name_list: read ea name %s\n", eal->ea.name));
 886         }
 887
 888         return ea_list_head;
 889 }
 890
 891 /****************************************************************************
 892  Read a list of EA names and data from an incoming data buffer. Create an ea_list with them.
 893 ****************************************************************************/
 894
 895 static struct ea_list *read_ea_list(TALLOC_CTX *ctx, const char *pdata, size_t data_size)
 896 {
 897         struct ea_list *ea_list_head = NULL;
 898         size_t offset = 0;
 899         size_t bytes_used = 0;
 900
 901         while (offset < data_size) {
 902                 struct ea_list *eal = read_ea_list_entry(ctx, pdata + offset, data_size - offset, &bytes_used);
 903
 904                 if (!eal) {
 905                         return NULL;
 906                 }
 907
 908                 DLIST_ADD_END(ea_list_head, eal);
 909                 offset += bytes_used;
 910         }
 911
 912         return ea_list_head;
 913 }
 914
 915 /****************************************************************************
 916  Count the total EA size needed.
 917 ****************************************************************************/
 918
 919 static size_t ea_list_size(struct ea_list *ealist)
 920 {
 921         fstring dos_ea_name;
 922         struct ea_list *listp;
 923         size_t ret = 0;
 924
 925         for (listp = ealist; listp; listp = listp->next) {
 926                 push_ascii_fstring(dos_ea_name, listp->ea.name);
 927                 ret += 4 + strlen(dos_ea_name) + 1 + listp->ea.value.length;
 928         }
 929         /* Add on 4 for total length. */
 930         if (ret) {
 931                 ret += 4;
 932         }
 933
 934         return ret;
 935 }
 936
 937 /****************************************************************************
 938  Return a union of EA's from a file list and a list of names.
 939  The TALLOC context for the two lists *MUST* be identical as we steal
 940  memory from one list to add to another. JRA.
 941 ****************************************************************************/
 942
 943 static struct ea_list *ea_list_union(struct ea_list *name_list, struct ea_list *file_list, size_t *total_ea_len)
 944 {
 945         struct ea_list *nlistp, *flistp;
 946
 947         for (nlistp = name_list; nlistp; nlistp = nlistp->next) {
 948                 for (flistp = file_list; flistp; flistp = flistp->next) {
 949                         if (strequal(nlistp->ea.name, flistp->ea.name)) {
 950                                 break;
 951                         }
 952                 }
 953
 954                 if (flistp) {
 955                         /* Copy the data from this entry. */
 956                         nlistp->ea.flags = flistp->ea.flags;
 957                         nlistp->ea.value = flistp->ea.value;
 958                 } else {
 959                         /* Null entry. */
 960                         nlistp->ea.flags = 0;
 961                         ZERO_STRUCT(nlistp->ea.value);
 962                 }
 963         }
 964
 965         *total_ea_len = ea_list_size(name_list);
 966         return name_list;
 967 }
 968
 969 /****************************************************************************
 970   Send the required number of replies back.
 971   We assume all fields other than the data fields are
 972   set correctly for the type of call.
 973   HACK ! Always assumes smb_setup field is zero.
 974 ****************************************************************************/
 975
 976 void send_trans2_replies(connection_struct *conn,
 977                         struct smb_request *req,
 978                         NTSTATUS status,
 979                          const char *params,
 980                          int paramsize,
 981                          const char *pdata,
 982                          int datasize,
 983                          int max_data_bytes)
 984 {
 985         /* As we are using a protocol > LANMAN1 then the max_send
 986          variable must have been set in the sessetupX call.
 987          This takes precedence over the max_xmit field in the
 988          global struct. These different max_xmit variables should
 989          be merged as this is now too confusing */
 990
 991         int data_to_send = datasize;
 992         int params_to_send = paramsize;
 993         int useable_space;
 994         const char *pp = params;
 995         const char *pd = pdata;
 996         int params_sent_thistime, data_sent_thistime, total_sent_thistime;
 997         int alignment_offset = 1; /* JRA. This used to be 3. Set to 1 to make netmon parse ok. */
 998         int data_alignment_offset = 0;
 999         bool overflow = False;
1000         struct smbXsrv_connection *xconn = req->xconn;
1001         int max_send = xconn->smb1.sessions.max_send;
1002
1003         /* Modify the data_to_send and datasize and set the error if
1004            we're trying to send more than max_data_bytes. We still send
1005            the part of the packet(s) that fit. Strange, but needed
1006            for OS/2. */
1007
1008         if (max_data_bytes > 0 && datasize > max_data_bytes) {
1009                 DEBUG(5,("send_trans2_replies: max_data_bytes %d exceeded by data %d\n",
1010                         max_data_bytes, datasize ));
1011                 datasize = data_to_send = max_data_bytes;
1012                 overflow = True;
1013         }
1014
1015         /* If there genuinely are no parameters or data to send just send the empty packet */
1016
1017         if(params_to_send == 0 && data_to_send == 0) {
1018                 reply_outbuf(req, 10, 0);
1019                 if (NT_STATUS_V(status)) {
1020                         uint8_t eclass;
1021                         uint32_t ecode;
1022                         ntstatus_to_dos(status, &eclass, &ecode);
1023                         error_packet_set((char *)req->outbuf,
1024                                         eclass, ecode, status,
1025                                         __LINE__,__FILE__);
1026                 }
1027                 show_msg((char *)req->outbuf);
1028                 if (!srv_send_smb(xconn,
1029                                 (char *)req->outbuf,
1030                                 true, req->seqnum+1,
1031                                 IS_CONN_ENCRYPTED(conn),
1032                                 &req->pcd)) {
1033                         exit_server_cleanly("send_trans2_replies: srv_send_smb failed.");
1034                 }
1035                 TALLOC_FREE(req->outbuf);
1036                 return;
1037         }
1038
1039         /* When sending params and data ensure that both are nicely aligned */
1040         /* Only do this alignment when there is also data to send - else
1041                 can cause NT redirector problems. */
1042
1043         if (((params_to_send % 4) != 0) && (data_to_send != 0))
1044                 data_alignment_offset = 4 - (params_to_send % 4);
1045
1046         /* Space is bufsize minus Netbios over TCP header minus SMB header */
1047         /* The alignment_offset is to align the param bytes on an even byte
1048                 boundary. NT 4.0 Beta needs this to work correctly. */
1049
1050         useable_space = max_send - (smb_size
1051                                     + 2 * 10 /* wct */
1052                                     + alignment_offset
1053                                     + data_alignment_offset);
1054
1055         if (useable_space < 0) {
1056                 DEBUG(0, ("send_trans2_replies failed sanity useable_space "
1057                           "= %d!!!", useable_space));
1058                 exit_server_cleanly("send_trans2_replies: Not enough space");
1059         }
1060
1061         while (params_to_send || data_to_send) {
1062                 /* Calculate whether we will totally or partially fill this packet */
1063
1064                 total_sent_thistime = params_to_send + data_to_send;
1065
1066                 /* We can never send more than useable_space */
1067                 /*
1068                  * Note that 'useable_space' does not include the alignment offsets,
1069                  * but we must include the alignment offsets in the calculation of
1070                  * the length of the data we send over the wire, as the alignment offsets
1071                  * are sent here. Fix from Marc_Jacobsen@hp.com.
1072                  */
1073
1074                 total_sent_thistime = MIN(total_sent_thistime, useable_space);
1075
1076                 reply_outbuf(req, 10, total_sent_thistime + alignment_offset
1077                              + data_alignment_offset);
1078
1079                 /* Set total params and data to be sent */
1080                 SSVAL(req->outbuf,smb_tprcnt,paramsize);
1081                 SSVAL(req->outbuf,smb_tdrcnt,datasize);
1082
1083                 /* Calculate how many parameters and data we can fit into
1084                  * this packet. Parameters get precedence
1085                  */
1086
1087                 params_sent_thistime = MIN(params_to_send,useable_space);
1088                 data_sent_thistime = useable_space - params_sent_thistime;
1089                 data_sent_thistime = MIN(data_sent_thistime,data_to_send);
1090
1091                 SSVAL(req->outbuf,smb_prcnt, params_sent_thistime);
1092
1093                 /* smb_proff is the offset from the start of the SMB header to the
1094                         parameter bytes, however the first 4 bytes of outbuf are
1095                         the Netbios over TCP header. Thus use smb_base() to subtract
1096                         them from the calculation */
1097
1098                 SSVAL(req->outbuf,smb_proff,
1099                       ((smb_buf(req->outbuf)+alignment_offset)
1100                        - smb_base(req->outbuf)));
1101
1102                 if(params_sent_thistime == 0)
1103                         SSVAL(req->outbuf,smb_prdisp,0);
1104                 else
1105                         /* Absolute displacement of param bytes sent in this packet */
1106                         SSVAL(req->outbuf,smb_prdisp,pp - params);
1107
1108                 SSVAL(req->outbuf,smb_drcnt, data_sent_thistime);
1109                 if(data_sent_thistime == 0) {
1110                         SSVAL(req->outbuf,smb_droff,0);
1111                         SSVAL(req->outbuf,smb_drdisp, 0);
1112                 } else {
1113                         /* The offset of the data bytes is the offset of the
1114                                 parameter bytes plus the number of parameters being sent this time */
1115                         SSVAL(req->outbuf, smb_droff,
1116                               ((smb_buf(req->outbuf)+alignment_offset)
1117                                - smb_base(req->outbuf))
1118                               + params_sent_thistime + data_alignment_offset);
1119                         SSVAL(req->outbuf,smb_drdisp, pd - pdata);
1120                 }
1121
1122                 /* Initialize the padding for alignment */
1123
1124                 if (alignment_offset != 0) {
1125                         memset(smb_buf(req->outbuf), 0, alignment_offset);
1126                 }
1127
1128                 /* Copy the param bytes into the packet */
1129
1130                 if(params_sent_thistime) {
1131                         memcpy((smb_buf(req->outbuf)+alignment_offset), pp,
1132                                params_sent_thistime);
1133                 }
1134
1135                 /* Copy in the data bytes */
1136                 if(data_sent_thistime) {
1137                         if (data_alignment_offset != 0) {
1138                                 memset((smb_buf(req->outbuf)+alignment_offset+
1139                                         params_sent_thistime), 0,
1140                                        data_alignment_offset);
1141                         }
1142                         memcpy(smb_buf(req->outbuf)+alignment_offset
1143                                +params_sent_thistime+data_alignment_offset,
1144                                pd,data_sent_thistime);
1145                 }
1146
1147                 DEBUG(9,("t2_rep: params_sent_thistime = %d, data_sent_thistime = %d, useable_space = %d\n",
1148                         params_sent_thistime, data_sent_thistime, useable_space));
1149                 DEBUG(9,("t2_rep: params_to_send = %d, data_to_send = %d, paramsize = %d, datasize = %d\n",
1150                         params_to_send, data_to_send, paramsize, datasize));
1151
1152                 if (overflow) {
1153                         error_packet_set((char *)req->outbuf,
1154                                          ERRDOS,ERRbufferoverflow,
1155                                          STATUS_BUFFER_OVERFLOW,
1156                                          __LINE__,__FILE__);
1157                 } else if (NT_STATUS_V(status)) {
1158                         uint8_t eclass;
1159                         uint32_t ecode;
1160                         ntstatus_to_dos(status, &eclass, &ecode);
1161                         error_packet_set((char *)req->outbuf,
1162                                         eclass, ecode, status,
1163                                         __LINE__,__FILE__);
1164                 }
1165
1166                 /* Send the packet */
1167                 show_msg((char *)req->outbuf);
1168                 if (!srv_send_smb(xconn,
1169                                 (char *)req->outbuf,
1170                                 true, req->seqnum+1,
1171                                 IS_CONN_ENCRYPTED(conn),
1172                                 &req->pcd))
1173                         exit_server_cleanly("send_trans2_replies: srv_send_smb failed.");
1174
1175                 TALLOC_FREE(req->outbuf);
1176
1177                 pp += params_sent_thistime;
1178                 pd += data_sent_thistime;
1179
1180                 params_to_send -= params_sent_thistime;
1181                 data_to_send -= data_sent_thistime;
1182
1183                 /* Sanity check */
1184                 if(params_to_send < 0 || data_to_send < 0) {
1185                         DEBUG(0,("send_trans2_replies failed sanity check pts = %d, dts = %d\n!!!",
1186                                 params_to_send, data_to_send));
1187                         return;
1188                 }
1189         }
1190
1191         return;
1192 }
1193
1194 /****************************************************************************
1195  Reply to a TRANSACT2_OPEN.
1196 ****************************************************************************/
1197
1198 static void call_trans2open(connection_struct *conn,
1199                             struct smb_request *req,
1200                             char **pparams, int total_params,
1201                             char **ppdata, int total_data,
1202                             unsigned int max_data_bytes)
1203 {
1204         struct smb_filename *smb_fname = NULL;
1205         char *params = *pparams;
1206         char *pdata = *ppdata;
1207         int deny_mode;
1208         int32_t open_attr;
1209         bool oplock_request;
1210 #if 0
1211         bool return_additional_info;
1212         int16 open_sattr;
1213         time_t open_time;
1214 #endif
1215         int open_ofun;
1216         uint32_t open_size;
1217         char *pname;
1218         char *fname = NULL;
1219         off_t size=0;
1220         int fattr=0,mtime=0;
1221         SMB_INO_T inode = 0;
1222         int smb_action = 0;
1223         files_struct *fsp;
1224         struct ea_list *ea_list = NULL;
1225         uint16_t flags = 0;
1226         NTSTATUS status;
1227         uint32_t access_mask;
1228         uint32_t share_mode;
1229         uint32_t create_disposition;
1230         uint32_t create_options = 0;
1231         uint32_t private_flags = 0;
1232         uint32_t ucf_flags = ucf_flags_from_smb_request(req);
1233         TALLOC_CTX *ctx = talloc_tos();
1234
1235         /*
1236          * Ensure we have enough parameters to perform the operation.
1237          */
1238
1239         if (total_params < 29) {
1240                 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
1241                 goto out;
1242         }
1243
1244         flags = SVAL(params, 0);
1245         deny_mode = SVAL(params, 2);
1246         open_attr = SVAL(params,6);
1247         oplock_request = (flags & REQUEST_OPLOCK) ? EXCLUSIVE_OPLOCK : 0;
1248         if (oplock_request) {
1249                 oplock_request |= (flags & REQUEST_BATCH_OPLOCK) ? BATCH_OPLOCK : 0;
1250         }
1251
1252 #if 0
1253         return_additional_info = BITSETW(params,0);
1254         open_sattr = SVAL(params, 4);
1255         open_time = make_unix_date3(params+8);
1256 #endif
1257         open_ofun = SVAL(params,12);
1258         open_size = IVAL(params,14);
1259         pname = &params[28];
1260
1261         if (IS_IPC(conn)) {
1262                 reply_nterror(req, NT_STATUS_NETWORK_ACCESS_DENIED);
1263                 goto out;
1264         }
1265
1266         if (req->posix_pathnames) {
1267                 srvstr_get_path_posix(ctx,
1268                         params,
1269                         req->flags2,
1270                         &fname,
1271                         pname,
1272                         total_params - 28,
1273                         STR_TERMINATE,
1274                         &status);
1275         } else {
1276                 srvstr_get_path(ctx,
1277                         params,
1278                         req->flags2,
1279                         &fname,
1280                         pname,
1281                         total_params - 28,
1282                         STR_TERMINATE,
1283                         &status);
1284         }
1285         if (!NT_STATUS_IS_OK(status)) {
1286                 reply_nterror(req, status);
1287                 goto out;
1288         }
1289
1290         DEBUG(3,("call_trans2open %s deny_mode=0x%x attr=%d ofun=0x%x size=%d\n",
1291                 fname, (unsigned int)deny_mode, (unsigned int)open_attr,
1292                 (unsigned int)open_ofun, open_size));
1293
1294         status = filename_convert(ctx,
1295                                 conn,
1296                                 fname,
1297                                 ucf_flags,
1298                                 NULL,
1299                                 &smb_fname);
1300         if (!NT_STATUS_IS_OK(status)) {
1301                 if (NT_STATUS_EQUAL(status,NT_STATUS_PATH_NOT_COVERED)) {
1302                         reply_botherror(req,
1303                                 NT_STATUS_PATH_NOT_COVERED,
1304                                 ERRSRV, ERRbadpath);
1305                         goto out;
1306                 }
1307                 reply_nterror(req, status);
1308                 goto out;
1309         }
1310
1311         if (open_ofun == 0) {
1312                 reply_nterror(req, NT_STATUS_OBJECT_NAME_COLLISION);
1313                 goto out;
1314         }
1315
1316         if (!map_open_params_to_ntcreate(smb_fname->base_name, deny_mode,
1317                                          open_ofun,
1318                                          &access_mask, &share_mode,
1319                                          &create_disposition,
1320                                          &create_options,
1321                                          &private_flags)) {
1322                 reply_nterror(req, NT_STATUS_ACCESS_DENIED);
1323                 goto out;
1324         }
1325
1326         /* Any data in this call is an EA list. */
1327         if (total_data && (total_data != 4)) {
1328                 if (total_data < 10) {
1329                         reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
1330                         goto out;
1331                 }
1332
1333                 if (IVAL(pdata,0) > total_data) {
1334                         DEBUG(10,("call_trans2open: bad total data size (%u) > %u\n",
1335                                 IVAL(pdata,0), (unsigned int)total_data));
1336                         reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
1337                         goto out;
1338                 }
1339
1340                 ea_list = read_ea_list(talloc_tos(), pdata + 4,
1341                                        total_data - 4);
1342                 if (!ea_list) {
1343                         reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
1344                         goto out;
1345                 }
1346
1347                 if (!lp_ea_support(SNUM(conn))) {
1348                         reply_nterror(req, NT_STATUS_EAS_NOT_SUPPORTED);
1349                         goto out;
1350                 }
1351
1352                 if (!req->posix_pathnames &&
1353                                 ea_list_has_invalid_name(ea_list)) {
1354                         int param_len = 30;
1355                         *pparams = (char *)SMB_REALLOC(*pparams, param_len);
1356                         if(*pparams == NULL ) {
1357                                 reply_nterror(req, NT_STATUS_NO_MEMORY);
1358                                 goto out;
1359                         }
1360                         params = *pparams;
1361                         memset(params, '\0', param_len);
1362                         send_trans2_replies(conn, req, STATUS_INVALID_EA_NAME,
1363                                 params, param_len, NULL, 0, max_data_bytes);
1364                         goto out;
1365                 }
1366         }
1367
1368         status = SMB_VFS_CREATE_FILE(
1369                 conn,                                   /* conn */
1370                 req,                                    /* req */
1371                 0,                                      /* root_dir_fid */
1372                 smb_fname,                              /* fname */
1373                 access_mask,                            /* access_mask */
1374                 share_mode,                             /* share_access */
1375                 create_disposition,                     /* create_disposition*/
1376                 create_options,                         /* create_options */
1377                 open_attr,                              /* file_attributes */
1378                 oplock_request,                         /* oplock_request */
1379                 NULL,                                   /* lease */
1380                 open_size,                              /* allocation_size */
1381                 private_flags,
1382                 NULL,                                   /* sd */
1383                 ea_list,                                /* ea_list */
1384                 &fsp,                                   /* result */
1385                 &smb_action,                            /* psbuf */
1386                 NULL, NULL);                            /* create context */
1387
1388         if (!NT_STATUS_IS_OK(status)) {
1389                 if (open_was_deferred(req->xconn, req->mid)) {
1390                         /* We have re-scheduled this call. */
1391                         goto out;
1392                 }
1393                 reply_openerror(req, status);
1394                 goto out;
1395         }
1396
1397         size = get_file_size_stat(&smb_fname->st);
1398         fattr = dos_mode(conn, smb_fname);
1399         mtime = convert_timespec_to_time_t(smb_fname->st.st_ex_mtime);
1400         inode = smb_fname->st.st_ex_ino;
1401         if (fattr & FILE_ATTRIBUTE_DIRECTORY) {
1402                 close_file(req, fsp, ERROR_CLOSE);
1403                 reply_nterror(req, NT_STATUS_ACCESS_DENIED);
1404                 goto out;
1405         }
1406
1407         /* Realloc the size of parameters and data we will return */
1408         *pparams = (char *)SMB_REALLOC(*pparams, 30);
1409         if(*pparams == NULL ) {
1410                 reply_nterror(req, NT_STATUS_NO_MEMORY);
1411                 goto out;
1412         }
1413         params = *pparams;
1414
1415         SSVAL(params,0,fsp->fnum);
1416         SSVAL(params,2,fattr);
1417         srv_put_dos_date2(params,4, mtime);
1418         SIVAL(params,8, (uint32_t)size);
1419         SSVAL(params,12,deny_mode);
1420         SSVAL(params,14,0); /* open_type - file or directory. */
1421         SSVAL(params,16,0); /* open_state - only valid for IPC device. */
1422
1423         if (oplock_request && lp_fake_oplocks(SNUM(conn))) {
1424                 smb_action |= EXTENDED_OPLOCK_GRANTED;
1425         }
1426
1427         SSVAL(params,18,smb_action);
1428
1429         /*
1430          * WARNING - this may need to be changed if SMB_INO_T <> 4 bytes.
1431          */
1432         SIVAL(params,20,inode);
1433         SSVAL(params,24,0); /* Padding. */
1434         if (flags & 8) {
1435                 uint32_t ea_size = estimate_ea_size(conn, fsp,
1436                                                   smb_fname);
1437                 SIVAL(params, 26, ea_size);
1438         } else {
1439                 SIVAL(params, 26, 0);
1440         }
1441
1442         /* Send the required number of replies */
1443         send_trans2_replies(conn, req, NT_STATUS_OK, params, 30, *ppdata, 0, max_data_bytes);
1444  out:
1445         TALLOC_FREE(smb_fname);
1446 }
1447
1448 /*********************************************************
1449  Routine to check if a given string matches exactly.
1450  as a special case a mask of "." does NOT match. That
1451  is required for correct wildcard semantics
1452  Case can be significant or not.
1453 **********************************************************/
1454
1455 static bool exact_match(bool has_wild,
1456                         bool case_sensitive,
1457                         const char *str,
1458                         const char *mask)
1459 {
1460         if (mask[0] == '.' && mask[1] == 0) {
1461                 return false;
1462         }
1463
1464         if (has_wild) {
1465                 return false;
1466         }
1467
1468         if (case_sensitive) {
1469                 return strcmp(str,mask)==0;
1470         } else {
1471                 return strcasecmp_m(str,mask) == 0;
1472         }
1473 }
1474
1475 /****************************************************************************
1476  Return the filetype for UNIX extensions.
1477 ****************************************************************************/
1478
1479 static uint32_t unix_filetype(mode_t mode)
1480 {
1481         if(S_ISREG(mode))
1482                 return UNIX_TYPE_FILE;
1483         else if(S_ISDIR(mode))
1484                 return UNIX_TYPE_DIR;
1485 #ifdef S_ISLNK
1486         else if(S_ISLNK(mode))
1487                 return UNIX_TYPE_SYMLINK;
1488 #endif
1489 #ifdef S_ISCHR
1490         else if(S_ISCHR(mode))
1491                 return UNIX_TYPE_CHARDEV;
1492 #endif
1493 #ifdef S_ISBLK
1494         else if(S_ISBLK(mode))
1495                 return UNIX_TYPE_BLKDEV;
1496 #endif
1497 #ifdef S_ISFIFO
1498         else if(S_ISFIFO(mode))
1499                 return UNIX_TYPE_FIFO;
1500 #endif
1501 #ifdef S_ISSOCK
1502         else if(S_ISSOCK(mode))
1503                 return UNIX_TYPE_SOCKET;
1504 #endif
1505
1506         DEBUG(0,("unix_filetype: unknown filetype %u\n", (unsigned)mode));
1507         return UNIX_TYPE_UNKNOWN;
1508 }
1509
1510 /****************************************************************************
1511  Map wire perms onto standard UNIX permissions. Obey share restrictions.
1512 ****************************************************************************/
1513
1514 enum perm_type { PERM_NEW_FILE, PERM_NEW_DIR, PERM_EXISTING_FILE, PERM_EXISTING_DIR};
1515
1516 static NTSTATUS unix_perms_from_wire( connection_struct *conn,
1517                                 const SMB_STRUCT_STAT *psbuf,
1518                                 uint32_t perms,
1519                                 enum perm_type ptype,
1520                                 mode_t *ret_perms)
1521 {
1522         mode_t ret = 0;
1523
1524         if (perms == SMB_MODE_NO_CHANGE) {
1525                 if (!VALID_STAT(*psbuf)) {
1526                         return NT_STATUS_INVALID_PARAMETER;
1527                 } else {
1528                         *ret_perms = psbuf->st_ex_mode;
1529                         return NT_STATUS_OK;
1530                 }
1531         }
1532
1533         ret |= ((perms & UNIX_X_OTH ) ? S_IXOTH : 0);
1534         ret |= ((perms & UNIX_W_OTH ) ? S_IWOTH : 0);
1535         ret |= ((perms & UNIX_R_OTH ) ? S_IROTH : 0);
1536         ret |= ((perms & UNIX_X_GRP ) ? S_IXGRP : 0);
1537         ret |= ((perms & UNIX_W_GRP ) ? S_IWGRP : 0);
1538         ret |= ((perms & UNIX_R_GRP ) ? S_IRGRP : 0);
1539         ret |= ((perms & UNIX_X_USR ) ? S_IXUSR : 0);
1540         ret |= ((perms & UNIX_W_USR ) ? S_IWUSR : 0);
1541         ret |= ((perms & UNIX_R_USR ) ? S_IRUSR : 0);
1542 #ifdef S_ISVTX
1543         ret |= ((perms & UNIX_STICKY ) ? S_ISVTX : 0);
1544 #endif
1545 #ifdef S_ISGID
1546         ret |= ((perms & UNIX_SET_GID ) ? S_ISGID : 0);
1547 #endif
1548 #ifdef S_ISUID
1549         ret |= ((perms & UNIX_SET_UID ) ? S_ISUID : 0);
1550 #endif
1551
1552         if (ptype == PERM_NEW_FILE) {
1553                 /*
1554                  * "create mask"/"force create mode" are
1555                  * only applied to new files, not existing ones.
1556                  */
1557                 ret &= lp_create_mask(SNUM(conn));
1558                 /* Add in force bits */
1559                 ret |= lp_force_create_mode(SNUM(conn));
1560         } else if (ptype == PERM_NEW_DIR) {
1561                 /*
1562                  * "directory mask"/"force directory mode" are
1563                  * only applied to new directories, not existing ones.
1564                  */
1565                 ret &= lp_directory_mask(SNUM(conn));
1566                 /* Add in force bits */
1567                 ret |= lp_force_directory_mode(SNUM(conn));
1568         }
1569
1570         *ret_perms = ret;
1571         return NT_STATUS_OK;
1572 }
1573
1574 /****************************************************************************
1575  Needed to show the msdfs symlinks as directories. Modifies psbuf
1576  to be a directory if it's a msdfs link.
1577 ****************************************************************************/
1578
1579 static bool check_msdfs_link(connection_struct *conn,
1580                                 struct smb_filename *smb_fname)
1581 {
1582         int saved_errno = errno;
1583         if(lp_host_msdfs() &&
1584                 lp_msdfs_root(SNUM(conn)) &&
1585                 is_msdfs_link(conn, smb_fname)) {
1586
1587                 DEBUG(5,("check_msdfs_link: Masquerading msdfs link %s "
1588                         "as a directory\n",
1589                         smb_fname->base_name));
1590                 smb_fname->st.st_ex_mode =
1591                         (smb_fname->st.st_ex_mode & 0xFFF) | S_IFDIR;
1592                 errno = saved_errno;
1593                 return true;
1594         }
1595         errno = saved_errno;
1596         return false;
1597 }
1598
1599
1600 /****************************************************************************
1601  Get a level dependent lanman2 dir entry.
1602 ****************************************************************************/
1603
1604 struct smbd_dirptr_lanman2_state {
1605         connection_struct *conn;
1606         uint32_t info_level;
1607         bool check_mangled_names;
1608         bool has_wild;
1609         bool got_exact_match;
1610 };
1611
1612 static bool smbd_dirptr_lanman2_match_fn(TALLOC_CTX *ctx,
1613                                          void *private_data,
1614                                          const char *dname,
1615                                          const char *mask,
1616                                          char **_fname)
1617 {
1618         struct smbd_dirptr_lanman2_state *state =
1619                 (struct smbd_dirptr_lanman2_state *)private_data;
1620         bool ok;
1621         char mangled_name[13]; /* mangled 8.3 name. */
1622         bool got_match;
1623         const char *fname;
1624
1625         /* Mangle fname if it's an illegal name. */
1626         if (mangle_must_mangle(dname, state->conn->params)) {
1627                 /*
1628                  * Slow path - ensure we can push the original name as UCS2. If
1629                  * not, then just don't return this name.
1630                  */
1631                 NTSTATUS status;
1632                 size_t ret_len = 0;
1633                 size_t len = (strlen(dname) + 2) * 4; /* Allow enough space. */
1634                 uint8_t *tmp = talloc_array(talloc_tos(),
1635                                         uint8_t,
1636                                         len);
1637
1638                 status = srvstr_push(NULL,
1639                         FLAGS2_UNICODE_STRINGS,
1640                         tmp,
1641                         dname,
1642                         len,
1643                         STR_TERMINATE,
1644                         &ret_len);
1645
1646                 TALLOC_FREE(tmp);
1647
1648                 if (!NT_STATUS_IS_OK(status)) {
1649                         return false;
1650                 }
1651
1652                 ok = name_to_8_3(dname, mangled_name,
1653                                  true, state->conn->params);
1654                 if (!ok) {
1655                         return false;
1656                 }
1657                 fname = mangled_name;
1658         } else {
1659                 fname = dname;
1660         }
1661
1662         got_match = exact_match(state->has_wild,
1663                                 state->conn->case_sensitive,
1664                                 fname, mask);
1665         state->got_exact_match = got_match;
1666         if (!got_match) {
1667                 got_match = mask_match(fname, mask,
1668                                        state->conn->case_sensitive);
1669         }
1670
1671         if(!got_match && state->check_mangled_names &&
1672            !mangle_is_8_3(fname, false, state->conn->params)) {
1673                 /*
1674                  * It turns out that NT matches wildcards against
1675                  * both long *and* short names. This may explain some
1676                  * of the wildcard wierdness from old DOS clients
1677                  * that some people have been seeing.... JRA.
1678                  */
1679                 /* Force the mangling into 8.3. */
1680                 ok = name_to_8_3(fname, mangled_name,
1681                                  false, state->conn->params);
1682                 if (!ok) {
1683                         return false;
1684                 }
1685
1686                 got_match = exact_match(state->has_wild,
1687                                         state->conn->case_sensitive,
1688                                         mangled_name, mask);
1689                 state->got_exact_match = got_match;
1690                 if (!got_match) {
1691                         got_match = mask_match(mangled_name, mask,
1692                                                state->conn->case_sensitive);
1693                 }
1694         }
1695
1696         if (!got_match) {
1697                 return false;
1698         }
1699
1700         *_fname = talloc_strdup(ctx, fname);
1701         if (*_fname == NULL) {
1702                 return false;
1703         }
1704
1705         return true;
1706 }
1707
1708 static bool smbd_dirptr_lanman2_mode_fn(TALLOC_CTX *ctx,
1709                                         void *private_data,
1710                                         struct smb_filename *smb_fname,
1711                                         uint32_t *_mode)
1712 {
1713         struct smbd_dirptr_lanman2_state *state =
1714                 (struct smbd_dirptr_lanman2_state *)private_data;
1715         bool ms_dfs_link = false;
1716         uint32_t mode = 0;
1717
1718         if (INFO_LEVEL_IS_UNIX(state->info_level)) {
1719                 if (SMB_VFS_LSTAT(state->conn, smb_fname) != 0) {
1720                         DEBUG(5,("smbd_dirptr_lanman2_mode_fn: "
1721                                  "Couldn't lstat [%s] (%s)\n",
1722                                  smb_fname_str_dbg(smb_fname),
1723                                  strerror(errno)));
1724                         return false;
1725                 }
1726         } else if (!VALID_STAT(smb_fname->st) &&
1727                    SMB_VFS_STAT(state->conn, smb_fname) != 0) {
1728                 /* Needed to show the msdfs symlinks as
1729                  * directories */
1730
1731                 ms_dfs_link = check_msdfs_link(state->conn,
1732                                                smb_fname);
1733                 if (!ms_dfs_link) {
1734                         DEBUG(5,("smbd_dirptr_lanman2_mode_fn: "
1735                                  "Couldn't stat [%s] (%s)\n",
1736                                  smb_fname_str_dbg(smb_fname),
1737                                  strerror(errno)));
1738                         return false;
1739                 }
1740         }
1741
1742         if (ms_dfs_link) {
1743                 mode = dos_mode_msdfs(state->conn, smb_fname);
1744         } else {
1745                 mode = dos_mode(state->conn, smb_fname);
1746         }
1747
1748         *_mode = mode;
1749         return true;
1750 }
1751
1752 static NTSTATUS smbd_marshall_dir_entry(TALLOC_CTX *ctx,
1753                                     connection_struct *conn,
1754                                     uint16_t flags2,
1755                                     uint32_t info_level,
1756                                     struct ea_list *name_list,
1757                                     bool check_mangled_names,
1758                                     bool requires_resume_key,
1759                                     uint32_t mode,
1760                                     const char *fname,
1761                                     const struct smb_filename *smb_fname,
1762                                     int space_remaining,
1763                                     uint8_t align,
1764                                     bool do_pad,
1765                                     char *base_data,
1766                                     char **ppdata,
1767                                     char *end_data,
1768                                     uint64_t *last_entry_off)
1769 {
1770         char *p, *q, *pdata = *ppdata;
1771         uint32_t reskey=0;
1772         uint64_t file_size = 0;
1773         uint64_t allocation_size = 0;
1774         uint64_t file_index = 0;
1775         size_t len = 0;
1776         struct timespec mdate_ts = {0};
1777         struct timespec adate_ts = {0};
1778         struct timespec cdate_ts = {0};
1779         struct timespec create_date_ts = {0};
1780         time_t mdate = (time_t)0, adate = (time_t)0, create_date = (time_t)0;
1781         char *nameptr;
1782         char *last_entry_ptr;
1783         bool was_8_3;
1784         int off;
1785         int pad = 0;
1786         NTSTATUS status;
1787         struct readdir_attr_data *readdir_attr_data = NULL;
1788
1789         if (!(mode & FILE_ATTRIBUTE_DIRECTORY)) {
1790                 file_size = get_file_size_stat(&smb_fname->st);
1791         }
1792         allocation_size = SMB_VFS_GET_ALLOC_SIZE(conn, NULL, &smb_fname->st);
1793
1794         status = SMB_VFS_READDIR_ATTR(conn, smb_fname, ctx, &readdir_attr_data);
1795         if (!NT_STATUS_IS_OK(status)) {
1796                 if (!NT_STATUS_EQUAL(NT_STATUS_NOT_SUPPORTED, status)) {
1797                         return status;
1798                 }
1799         }
1800
1801         file_index = get_FileIndex(conn, &smb_fname->st);
1802
1803         mdate_ts = smb_fname->st.st_ex_mtime;
1804         adate_ts = smb_fname->st.st_ex_atime;
1805         create_date_ts = get_create_timespec(conn, NULL, smb_fname);
1806         cdate_ts = get_change_timespec(conn, NULL, smb_fname);
1807
1808         if (lp_dos_filetime_resolution(SNUM(conn))) {
1809                 dos_filetime_timespec(&create_date_ts);
1810                 dos_filetime_timespec(&mdate_ts);
1811                 dos_filetime_timespec(&adate_ts);
1812                 dos_filetime_timespec(&cdate_ts);
1813         }
1814
1815         create_date = convert_timespec_to_time_t(create_date_ts);
1816         mdate = convert_timespec_to_time_t(mdate_ts);
1817         adate = convert_timespec_to_time_t(adate_ts);
1818
1819         /* align the record */
1820         SMB_ASSERT(align >= 1);
1821
1822         off = (int)PTR_DIFF(pdata, base_data);
1823         pad = (off + (align-1)) & ~(align-1);
1824         pad -= off;
1825
1826         if (pad && pad > space_remaining) {
1827                 DEBUG(9,("smbd_marshall_dir_entry: out of space "
1828                         "for padding (wanted %u, had %d)\n",
1829                         (unsigned int)pad,
1830                         space_remaining ));
1831                 return STATUS_MORE_ENTRIES; /* Not finished - just out of space */
1832         }
1833
1834         off += pad;
1835         /* initialize padding to 0 */
1836         if (pad) {
1837                 memset(pdata, 0, pad);
1838         }
1839         space_remaining -= pad;
1840
1841         DEBUG(10,("smbd_marshall_dir_entry: space_remaining = %d\n",
1842                 space_remaining ));
1843
1844         pdata += pad;
1845         p = pdata;
1846         last_entry_ptr = p;
1847
1848         pad = 0;
1849         off = 0;
1850
1851         switch (info_level) {
1852         case SMB_FIND_INFO_STANDARD:
1853                 DEBUG(10,("smbd_marshall_dir_entry: SMB_FIND_INFO_STANDARD\n"));
1854                 if(requires_resume_key) {
1855                         SIVAL(p,0,reskey);
1856                         p += 4;
1857                 }
1858                 srv_put_dos_date2(p,0,create_date);
1859                 srv_put_dos_date2(p,4,adate);
1860                 srv_put_dos_date2(p,8,mdate);
1861                 SIVAL(p,12,(uint32_t)file_size);
1862                 SIVAL(p,16,(uint32_t)allocation_size);
1863                 SSVAL(p,20,mode);
1864                 p += 23;
1865                 nameptr = p;
1866                 if (flags2 & FLAGS2_UNICODE_STRINGS) {
1867                         p += ucs2_align(base_data, p, 0);
1868                 }
1869                 status = srvstr_push(base_data, flags2, p,
1870                                   fname, PTR_DIFF(end_data, p),
1871                                   STR_TERMINATE, &len);
1872                 if (!NT_STATUS_IS_OK(status)) {
1873                         return status;
1874                 }
1875                 if (flags2 & FLAGS2_UNICODE_STRINGS) {
1876                         if (len > 2) {
1877                                 SCVAL(nameptr, -1, len - 2);
1878                         } else {
1879                                 SCVAL(nameptr, -1, 0);
1880                         }
1881                 } else {
1882                         if (len > 1) {
1883                                 SCVAL(nameptr, -1, len - 1);
1884                         } else {
1885                                 SCVAL(nameptr, -1, 0);
1886                         }
1887                 }
1888                 p += len;
1889                 break;
1890
1891         case SMB_FIND_EA_SIZE:
1892                 DEBUG(10,("smbd_marshall_dir_entry: SMB_FIND_EA_SIZE\n"));
1893                 if (requires_resume_key) {
1894                         SIVAL(p,0,reskey);
1895                         p += 4;
1896                 }
1897                 srv_put_dos_date2(p,0,create_date);
1898                 srv_put_dos_date2(p,4,adate);
1899                 srv_put_dos_date2(p,8,mdate);
1900                 SIVAL(p,12,(uint32_t)file_size);
1901                 SIVAL(p,16,(uint32_t)allocation_size);
1902                 SSVAL(p,20,mode);
1903                 {
1904                         unsigned int ea_size = estimate_ea_size(conn, NULL,
1905                                                                 smb_fname);
1906                         SIVAL(p,22,ea_size); /* Extended attributes */
1907                 }
1908                 p += 27;
1909                 nameptr = p - 1;
1910                 status = srvstr_push(base_data, flags2,
1911                                   p, fname, PTR_DIFF(end_data, p),
1912                                   STR_TERMINATE | STR_NOALIGN, &len);
1913                 if (!NT_STATUS_IS_OK(status)) {
1914                         return status;
1915                 }
1916                 if (flags2 & FLAGS2_UNICODE_STRINGS) {
1917                         if (len > 2) {
1918                                 len -= 2;
1919                         } else {
1920                                 len = 0;
1921                         }
1922                 } else {
1923                         if (len > 1) {
1924                                 len -= 1;
1925                         } else {
1926                                 len = 0;
1927                         }
1928                 }
1929                 SCVAL(nameptr,0,len);
1930                 p += len;
1931                 SCVAL(p,0,0); p += 1; /* Extra zero byte ? - why.. */
1932                 break;
1933
1934         case SMB_FIND_EA_LIST:
1935         {
1936                 struct ea_list *file_list = NULL;
1937                 size_t ea_len = 0;
1938
1939                 DEBUG(10,("smbd_marshall_dir_entry: SMB_FIND_EA_LIST\n"));
1940                 if (!name_list) {
1941                         return NT_STATUS_INVALID_PARAMETER;
1942                 }
1943                 if (requires_resume_key) {
1944                         SIVAL(p,0,reskey);
1945                         p += 4;
1946                 }
1947                 srv_put_dos_date2(p,0,create_date);
1948                 srv_put_dos_date2(p,4,adate);
1949                 srv_put_dos_date2(p,8,mdate);
1950                 SIVAL(p,12,(uint32_t)file_size);
1951                 SIVAL(p,16,(uint32_t)allocation_size);
1952                 SSVAL(p,20,mode);
1953                 p += 22; /* p now points to the EA area. */
1954
1955                 status = get_ea_list_from_file(ctx, conn, NULL,
1956                                                smb_fname,
1957                                                &ea_len, &file_list);
1958                 if (!NT_STATUS_IS_OK(status)) {
1959                         file_list = NULL;
1960                 }
1961                 name_list = ea_list_union(name_list, file_list, &ea_len);
1962
1963                 /* We need to determine if this entry will fit in the space available. */
1964                 /* Max string size is 255 bytes. */
1965                 if (PTR_DIFF(p + 255 + ea_len,pdata) > space_remaining) {
1966                         DEBUG(9,("smbd_marshall_dir_entry: out of space "
1967                                 "(wanted %u, had %d)\n",
1968                                 (unsigned int)PTR_DIFF(p + 255 + ea_len,pdata),
1969                                 space_remaining ));
1970                         return STATUS_MORE_ENTRIES; /* Not finished - just out of space */
1971                 }
1972
1973                 /* Push the ea_data followed by the name. */
1974                 p += fill_ea_buffer(ctx, p, space_remaining, conn, name_list);
1975                 nameptr = p;
1976                 status = srvstr_push(base_data, flags2,
1977                                   p + 1, fname, PTR_DIFF(end_data, p+1),
1978                                   STR_TERMINATE | STR_NOALIGN, &len);
1979                 if (!NT_STATUS_IS_OK(status)) {
1980                         return status;
1981                 }
1982                 if (flags2 & FLAGS2_UNICODE_STRINGS) {
1983                         if (len > 2) {
1984                                 len -= 2;
1985                         } else {
1986                                 len = 0;
1987                         }
1988                 } else {
1989                         if (len > 1) {
1990                                 len -= 1;
1991                         } else {
1992                                 len = 0;
1993                         }
1994                 }
1995                 SCVAL(nameptr,0,len);
1996                 p += len + 1;
1997                 SCVAL(p,0,0); p += 1; /* Extra zero byte ? - why.. */
1998                 break;
1999         }
2000
2001         case SMB_FIND_FILE_BOTH_DIRECTORY_INFO:
2002                 DEBUG(10,("smbd_marshall_dir_entry: SMB_FIND_FILE_BOTH_DIRECTORY_INFO\n"));
2003                 was_8_3 = mangle_is_8_3(fname, True, conn->params);
2004                 p += 4;
2005                 SIVAL(p,0,reskey); p += 4;
2006                 put_long_date_timespec(conn->ts_res,p,create_date_ts); p += 8;
2007                 put_long_date_timespec(conn->ts_res,p,adate_ts); p += 8;
2008                 put_long_date_timespec(conn->ts_res,p,mdate_ts); p += 8;
2009                 put_long_date_timespec(conn->ts_res,p,cdate_ts); p += 8;
2010                 SOFF_T(p,0,file_size); p += 8;
2011                 SOFF_T(p,0,allocation_size); p += 8;
2012                 SIVAL(p,0,mode); p += 4;
2013                 q = p; p += 4; /* q is placeholder for name length. */
2014                 if (mode & FILE_ATTRIBUTE_REPARSE_POINT) {
2015                         SIVAL(p, 0, IO_REPARSE_TAG_DFS);
2016                 } else {
2017                         unsigned int ea_size = estimate_ea_size(conn, NULL,
2018                                                                 smb_fname);
2019                         SIVAL(p,0,ea_size); /* Extended attributes */
2020                 }
2021                 p += 4;
2022                 /* Clear the short name buffer. This is
2023                  * IMPORTANT as not doing so will trigger
2024                  * a Win2k client bug. JRA.
2025                  */
2026                 if (!was_8_3 && check_mangled_names) {
2027                         char mangled_name[13]; /* mangled 8.3 name. */
2028                         if (!name_to_8_3(fname,mangled_name,True,
2029                                            conn->params)) {
2030                                 /* Error - mangle failed ! */
2031                                 memset(mangled_name,'\0',12);
2032                         }
2033                         mangled_name[12] = 0;
2034                         status = srvstr_push(base_data, flags2,
2035                                           p+2, mangled_name, 24,
2036                                           STR_UPPER|STR_UNICODE, &len);
2037                         if (!NT_STATUS_IS_OK(status)) {
2038                                 return status;
2039                         }
2040                         if (len < 24) {
2041                                 memset(p + 2 + len,'\0',24 - len);
2042                         }
2043                         SSVAL(p, 0, len);
2044                 } else {
2045                         memset(p,'\0',26);
2046                 }
2047                 p += 2 + 24;
2048                 status = srvstr_push(base_data, flags2, p,
2049                                   fname, PTR_DIFF(end_data, p),
2050                                   STR_TERMINATE_ASCII, &len);
2051                 if (!NT_STATUS_IS_OK(status)) {
2052                         return status;
2053                 }
2054                 SIVAL(q,0,len);
2055                 p += len;
2056
2057                 len = PTR_DIFF(p, pdata);
2058                 pad = (len + (align-1)) & ~(align-1);
2059                 /*
2060                  * offset to the next entry, the caller
2061                  * will overwrite it for the last entry
2062                  * that's why we always include the padding
2063                  */
2064                 SIVAL(pdata,0,pad);
2065                 /*
2066                  * set padding to zero
2067                  */
2068                 if (do_pad) {
2069                         memset(p, 0, pad - len);
2070                         p = pdata + pad;
2071                 } else {
2072                         p = pdata + len;
2073                 }
2074                 break;
2075
2076         case SMB_FIND_FILE_DIRECTORY_INFO:
2077                 DEBUG(10,("smbd_marshall_dir_entry: SMB_FIND_FILE_DIRECTORY_INFO\n"));
2078                 p += 4;
2079                 SIVAL(p,0,reskey); p += 4;
2080                 put_long_date_timespec(conn->ts_res,p,create_date_ts); p += 8;
2081                 put_long_date_timespec(conn->ts_res,p,adate_ts); p += 8;
2082                 put_long_date_timespec(conn->ts_res,p,mdate_ts); p += 8;
2083                 put_long_date_timespec(conn->ts_res,p,cdate_ts); p += 8;
2084                 SOFF_T(p,0,file_size); p += 8;
2085                 SOFF_T(p,0,allocation_size); p += 8;
2086                 SIVAL(p,0,mode); p += 4;
2087                 status = srvstr_push(base_data, flags2,
2088                                   p + 4, fname, PTR_DIFF(end_data, p+4),
2089                                   STR_TERMINATE_ASCII, &len);
2090                 if (!NT_STATUS_IS_OK(status)) {
2091                         return status;
2092                 }
2093                 SIVAL(p,0,len);
2094                 p += 4 + len;
2095
2096                 len = PTR_DIFF(p, pdata);
2097                 pad = (len + (align-1)) & ~(align-1);
2098                 /*
2099                  * offset to the next entry, the caller
2100                  * will overwrite it for the last entry
2101                  * that's why we always include the padding
2102                  */
2103                 SIVAL(pdata,0,pad);
2104                 /*
2105                  * set padding to zero
2106                  */
2107                 if (do_pad) {
2108                         memset(p, 0, pad - len);
2109                         p = pdata + pad;
2110                 } else {
2111                         p = pdata + len;
2112                 }
2113                 break;
2114
2115         case SMB_FIND_FILE_FULL_DIRECTORY_INFO:
2116                 DEBUG(10,("smbd_marshall_dir_entry: SMB_FIND_FILE_FULL_DIRECTORY_INFO\n"));
2117                 p += 4;
2118                 SIVAL(p,0,reskey); p += 4;
2119                 put_long_date_timespec(conn->ts_res,p,create_date_ts); p += 8;
2120                 put_long_date_timespec(conn->ts_res,p,adate_ts); p += 8;
2121                 put_long_date_timespec(conn->ts_res,p,mdate_ts); p += 8;
2122                 put_long_date_timespec(conn->ts_res,p,cdate_ts); p += 8;
2123                 SOFF_T(p,0,file_size); p += 8;
2124                 SOFF_T(p,0,allocation_size); p += 8;
2125                 SIVAL(p,0,mode); p += 4;
2126                 q = p; p += 4; /* q is placeholder for name length. */
2127                 {
2128                         unsigned int ea_size = estimate_ea_size(conn, NULL,
2129                                                                 smb_fname);
2130                         SIVAL(p,0,ea_size); /* Extended attributes */
2131                         p +=4;
2132                 }
2133                 status = srvstr_push(base_data, flags2, p,
2134                                   fname, PTR_DIFF(end_data, p),
2135                                   STR_TERMINATE_ASCII, &len);
2136                 if (!NT_STATUS_IS_OK(status)) {
2137                         return status;
2138                 }
2139                 SIVAL(q, 0, len);
2140                 p += len;
2141
2142                 len = PTR_DIFF(p, pdata);
2143                 pad = (len + (align-1)) & ~(align-1);
2144                 /*
2145                  * offset to the next entry, the caller
2146                  * will overwrite it for the last entry
2147                  * that's why we always include the padding
2148                  */
2149                 SIVAL(pdata,0,pad);
2150                 /*
2151                  * set padding to zero
2152                  */
2153                 if (do_pad) {
2154                         memset(p, 0, pad - len);
2155                         p = pdata + pad;
2156                 } else {
2157                         p = pdata + len;
2158                 }
2159                 break;
2160
2161         case SMB_FIND_FILE_NAMES_INFO:
2162                 DEBUG(10,("smbd_marshall_dir_entry: SMB_FIND_FILE_NAMES_INFO\n"));
2163                 p += 4;
2164                 SIVAL(p,0,reskey); p += 4;
2165                 p += 4;
2166                 /* this must *not* be null terminated or w2k gets in a loop trying to set an
2167                    acl on a dir (tridge) */
2168                 status = srvstr_push(base_data, flags2, p,
2169                                   fname, PTR_DIFF(end_data, p),
2170                                   STR_TERMINATE_ASCII, &len);
2171                 if (!NT_STATUS_IS_OK(status)) {
2172                         return status;
2173                 }
2174                 SIVAL(p, -4, len);
2175                 p += len;
2176
2177                 len = PTR_DIFF(p, pdata);
2178                 pad = (len + (align-1)) & ~(align-1);
2179                 /*
2180                  * offset to the next entry, the caller
2181                  * will overwrite it for the last entry
2182                  * that's why we always include the padding
2183                  */
2184                 SIVAL(pdata,0,pad);
2185                 /*
2186                  * set padding to zero
2187                  */
2188                 if (do_pad) {
2189                         memset(p, 0, pad - len);
2190                         p = pdata + pad;
2191                 } else {
2192                         p = pdata + len;
2193                 }
2194                 break;
2195
2196         case SMB_FIND_ID_FULL_DIRECTORY_INFO:
2197                 DEBUG(10,("smbd_marshall_dir_entry: SMB_FIND_ID_FULL_DIRECTORY_INFO\n"));
2198                 p += 4;
2199                 SIVAL(p,0,reskey); p += 4;
2200                 put_long_date_timespec(conn->ts_res,p,create_date_ts); p += 8;
2201                 put_long_date_timespec(conn->ts_res,p,adate_ts); p += 8;
2202                 put_long_date_timespec(conn->ts_res,p,mdate_ts); p += 8;
2203                 put_long_date_timespec(conn->ts_res,p,cdate_ts); p += 8;
2204                 SOFF_T(p,0,file_size); p += 8;
2205                 SOFF_T(p,0,allocation_size); p += 8;
2206                 SIVAL(p,0,mode); p += 4;
2207                 q = p; p += 4; /* q is placeholder for name length. */
2208                 if (mode & FILE_ATTRIBUTE_REPARSE_POINT) {
2209                         SIVAL(p, 0, IO_REPARSE_TAG_DFS);
2210                 } else {
2211                         unsigned int ea_size = estimate_ea_size(conn, NULL,
2212                                                                 smb_fname);
2213                         SIVAL(p,0,ea_size); /* Extended attributes */
2214                 }
2215                 p += 4;
2216                 SIVAL(p,0,0); p += 4; /* Unknown - reserved ? */
2217                 SBVAL(p,0,file_index); p += 8;
2218                 status = srvstr_push(base_data, flags2, p,
2219                                   fname, PTR_DIFF(end_data, p),
2220                                   STR_TERMINATE_ASCII, &len);
2221                 if (!NT_STATUS_IS_OK(status)) {
2222                         return status;
2223                 }
2224                 SIVAL(q, 0, len);
2225                 p += len;
2226
2227                 len = PTR_DIFF(p, pdata);
2228                 pad = (len + (align-1)) & ~(align-1);
2229                 /*
2230                  * offset to the next entry, the caller
2231                  * will overwrite it for the last entry
2232                  * that's why we always include the padding
2233                  */
2234                 SIVAL(pdata,0,pad);
2235                 /*
2236                  * set padding to zero
2237                  */
2238                 if (do_pad) {
2239                         memset(p, 0, pad - len);
2240                         p = pdata + pad;
2241                 } else {
2242                         p = pdata + len;
2243                 }
2244                 break;
2245
2246         case SMB_FIND_ID_BOTH_DIRECTORY_INFO:
2247                 DEBUG(10,("smbd_marshall_dir_entry: SMB_FIND_ID_BOTH_DIRECTORY_INFO\n"));
2248                 was_8_3 = mangle_is_8_3(fname, True, conn->params);
2249                 p += 4;
2250                 SIVAL(p,0,reskey); p += 4;
2251                 put_long_date_timespec(conn->ts_res,p,create_date_ts); p += 8;
2252                 put_long_date_timespec(conn->ts_res,p,adate_ts); p += 8;
2253                 put_long_date_timespec(conn->ts_res,p,mdate_ts); p += 8;
2254                 put_long_date_timespec(conn->ts_res,p,cdate_ts); p += 8;
2255                 SOFF_T(p,0,file_size); p += 8;
2256                 SOFF_T(p,0,allocation_size); p += 8;
2257                 SIVAL(p,0,mode); p += 4;
2258                 q = p; p += 4; /* q is placeholder for name length */
2259                 if (mode & FILE_ATTRIBUTE_REPARSE_POINT) {
2260                         SIVAL(p, 0, IO_REPARSE_TAG_DFS);
2261                 } else if (readdir_attr_data &&
2262                            readdir_attr_data->type == RDATTR_AAPL) {
2263                         /*
2264                          * OS X specific SMB2 extension negotiated via
2265                          * AAPL create context: return max_access in
2266                          * ea_size field.
2267                          */
2268                         SIVAL(p, 0, readdir_attr_data->attr_data.aapl.max_access);
2269                 } else {
2270                         unsigned int ea_size = estimate_ea_size(conn, NULL,
2271                                                                 smb_fname);
2272                         SIVAL(p,0,ea_size); /* Extended attributes */
2273                 }
2274                 p += 4;
2275
2276                 if (readdir_attr_data &&
2277                     readdir_attr_data->type == RDATTR_AAPL) {
2278                         /*
2279                          * OS X specific SMB2 extension negotiated via
2280                          * AAPL create context: return resource fork
2281                          * length and compressed FinderInfo in
2282                          * shortname field.
2283                          *
2284                          * According to documentation short_name_len
2285                          * should be 0, but on the wire behaviour
2286                          * shows its set to 24 by clients.
2287                          */
2288                         SSVAL(p, 0, 24);
2289
2290                         /* Resourefork length */
2291                         SBVAL(p, 2, readdir_attr_data->attr_data.aapl.rfork_size);
2292
2293                         /* Compressed FinderInfo */
2294                         memcpy(p + 10, &readdir_attr_data->attr_data.aapl.finder_info, 16);
2295                 } else if (!was_8_3 && check_mangled_names) {
2296                         char mangled_name[13]; /* mangled 8.3 name. */
2297                         if (!name_to_8_3(fname,mangled_name,True,
2298                                         conn->params)) {
2299                                 /* Error - mangle failed ! */
2300                                 memset(mangled_name,'\0',12);
2301                         }
2302                         mangled_name[12] = 0;
2303                         status = srvstr_push(base_data, flags2,
2304                                           p+2, mangled_name, 24,
2305                                           STR_UPPER|STR_UNICODE, &len);
2306                         if (!NT_STATUS_IS_OK(status)) {
2307                                 return status;
2308                         }
2309                         SSVAL(p, 0, len);
2310                         if (len < 24) {
2311                                 memset(p + 2 + len,'\0',24 - len);
2312                         }
2313                         SSVAL(p, 0, len);
2314                 } else {
2315                         /* Clear the short name buffer. This is
2316                          * IMPORTANT as not doing so will trigger
2317                          * a Win2k client bug. JRA.
2318                          */
2319                         memset(p,'\0',26);
2320                 }
2321                 p += 26;
2322
2323                 /* Reserved ? */
2324                 if (readdir_attr_data &&
2325                     readdir_attr_data->type == RDATTR_AAPL) {
2326                         /*
2327                          * OS X specific SMB2 extension negotiated via
2328                          * AAPL create context: return UNIX mode in
2329                          * reserved field.
2330                          */
2331                         uint16_t aapl_mode = (uint16_t)readdir_attr_data->attr_data.aapl.unix_mode;
2332                         SSVAL(p, 0, aapl_mode);
2333                 } else {
2334                         SSVAL(p, 0, 0);
2335                 }
2336                 p += 2;
2337
2338                 SBVAL(p,0,file_index); p += 8;
2339                 status = srvstr_push(base_data, flags2, p,
2340                                   fname, PTR_DIFF(end_data, p),
2341                                   STR_TERMINATE_ASCII, &len);
2342                 if (!NT_STATUS_IS_OK(status)) {
2343                         return status;
2344                 }
2345                 SIVAL(q,0,len);
2346                 p += len;
2347
2348                 len = PTR_DIFF(p, pdata);
2349                 pad = (len + (align-1)) & ~(align-1);
2350                 /*
2351                  * offset to the next entry, the caller
2352                  * will overwrite it for the last entry
2353                  * that's why we always include the padding
2354                  */
2355                 SIVAL(pdata,0,pad);
2356                 /*
2357                  * set padding to zero
2358                  */
2359                 if (do_pad) {
2360                         memset(p, 0, pad - len);
2361                         p = pdata + pad;
2362                 } else {
2363                         p = pdata + len;
2364                 }
2365                 break;
2366
2367         /* CIFS UNIX Extension. */
2368
2369         case SMB_FIND_FILE_UNIX:
2370         case SMB_FIND_FILE_UNIX_INFO2:
2371                 p+= 4;
2372                 SIVAL(p,0,reskey); p+= 4;    /* Used for continuing search. */
2373
2374                 /* Begin of SMB_QUERY_FILE_UNIX_BASIC */
2375
2376                 if (info_level == SMB_FIND_FILE_UNIX) {
2377                         DEBUG(10,("smbd_marshall_dir_entry: SMB_FIND_FILE_UNIX\n"));
2378                         p = store_file_unix_basic(conn, p,
2379                                                 NULL, &smb_fname->st);
2380                         status = srvstr_push(base_data, flags2, p,
2381                                           fname, PTR_DIFF(end_data, p),
2382                                           STR_TERMINATE, &len);
2383                         if (!NT_STATUS_IS_OK(status)) {
2384                                 return status;
2385                         }
2386                 } else {
2387                         DEBUG(10,("smbd_marshall_dir_entry: SMB_FIND_FILE_UNIX_INFO2\n"));
2388                         p = store_file_unix_basic_info2(conn, p,
2389                                                 NULL, &smb_fname->st);
2390                         nameptr = p;
2391                         p += 4;
2392                         status = srvstr_push(base_data, flags2, p, fname,
2393                                           PTR_DIFF(end_data, p), 0, &len);
2394                         if (!NT_STATUS_IS_OK(status)) {
2395                                 return status;
2396                         }
2397                         SIVAL(nameptr, 0, len);
2398                 }
2399
2400                 p += len;
2401
2402                 len = PTR_DIFF(p, pdata);
2403                 pad = (len + (align-1)) & ~(align-1);
2404                 /*
2405                  * offset to the next entry, the caller
2406                  * will overwrite it for the last entry
2407                  * that's why we always include the padding
2408                  */
2409                 SIVAL(pdata,0,pad);
2410                 /*
2411                  * set padding to zero
2412                  */
2413                 if (do_pad) {
2414                         memset(p, 0, pad - len);
2415                         p = pdata + pad;
2416                 } else {
2417                         p = pdata + len;
2418                 }
2419                 /* End of SMB_QUERY_FILE_UNIX_BASIC */
2420
2421                 break;
2422
2423         default:
2424                 return NT_STATUS_INVALID_LEVEL;
2425         }
2426
2427         if (PTR_DIFF(p,pdata) > space_remaining) {
2428                 DEBUG(9,("smbd_marshall_dir_entry: out of space "
2429                         "(wanted %u, had %d)\n",
2430                         (unsigned int)PTR_DIFF(p,pdata),
2431                         space_remaining ));
2432                 return STATUS_MORE_ENTRIES; /* Not finished - just out of space */
2433         }
2434
2435         /* Setup the last entry pointer, as an offset from base_data */
2436         *last_entry_off = PTR_DIFF(last_entry_ptr,base_data);
2437         /* Advance the data pointer to the next slot */
2438         *ppdata = p;
2439
2440         return NT_STATUS_OK;
2441 }
2442
2443 NTSTATUS smbd_dirptr_lanman2_entry(TALLOC_CTX *ctx,
2444                                connection_struct *conn,
2445                                struct dptr_struct *dirptr,
2446                                uint16_t flags2,
2447                                const char *path_mask,
2448                                uint32_t dirtype,
2449                                int info_level,
2450                                int requires_resume_key,
2451                                bool dont_descend,
2452                                bool ask_sharemode,
2453                                uint8_t align,
2454                                bool do_pad,
2455                                char **ppdata,
2456                                char *base_data,
2457                                char *end_data,
2458                                int space_remaining,
2459                                bool *got_exact_match,
2460                                int *_last_entry_off,
2461                                struct ea_list *name_list,
2462                                struct file_id *file_id)
2463 {
2464         const char *p;
2465         const char *mask = NULL;
2466         long prev_dirpos = 0;
2467         uint32_t mode = 0;
2468         char *fname = NULL;
2469         struct smb_filename *smb_fname = NULL;
2470         struct smbd_dirptr_lanman2_state state;
2471         bool ok;
2472         uint64_t last_entry_off = 0;
2473         NTSTATUS status;
2474         enum mangled_names_options mangled_names;
2475         bool marshall_with_83_names;
2476
2477         mangled_names = lp_mangled_names(conn->params);
2478
2479         ZERO_STRUCT(state);
2480         state.conn = conn;
2481         state.info_level = info_level;
2482         if (mangled_names != MANGLED_NAMES_NO) {
2483                 state.check_mangled_names = true;
2484         }
2485         state.has_wild = dptr_has_wild(dirptr);
2486         state.got_exact_match = false;
2487
2488         *got_exact_match = false;
2489
2490         p = strrchr_m(path_mask,'/');
2491         if(p != NULL) {
2492                 if(p[1] == '\0') {
2493                         mask = "*.*";
2494                 } else {
2495                         mask = p+1;
2496                 }
2497         } else {
2498                 mask = path_mask;
2499         }
2500
2501         ok = smbd_dirptr_get_entry(ctx,
2502                                    dirptr,
2503                                    mask,
2504                                    dirtype,
2505                                    dont_descend,
2506                                    ask_sharemode,
2507                                    smbd_dirptr_lanman2_match_fn,
2508                                    smbd_dirptr_lanman2_mode_fn,
2509                                    &state,
2510                                    &fname,
2511                                    &smb_fname,
2512                                    &mode,
2513                                    &prev_dirpos);
2514         if (!ok) {
2515                 return NT_STATUS_END_OF_FILE;
2516         }
2517
2518         *got_exact_match = state.got_exact_match;
2519
2520         marshall_with_83_names = (mangled_names == MANGLED_NAMES_YES);
2521
2522         status = smbd_marshall_dir_entry(ctx,
2523                                      conn,
2524                                      flags2,
2525                                      info_level,
2526                                      name_list,
2527                                      marshall_with_83_names,
2528                                      requires_resume_key,
2529                                      mode,
2530                                      fname,
2531                                      smb_fname,
2532                                      space_remaining,
2533                                      align,
2534                                      do_pad,
2535                                      base_data,
2536                                      ppdata,
2537                                      end_data,
2538                                      &last_entry_off);
2539         if (NT_STATUS_EQUAL(status, NT_STATUS_ILLEGAL_CHARACTER)) {
2540                 DEBUG(1,("Conversion error: illegal character: %s\n",
2541                          smb_fname_str_dbg(smb_fname)));
2542         }
2543
2544         if (file_id != NULL) {
2545                 *file_id = vfs_file_id_from_sbuf(conn, &smb_fname->st);
2546         }
2547
2548         TALLOC_FREE(fname);
2549         TALLOC_FREE(smb_fname);
2550         if (NT_STATUS_EQUAL(status, STATUS_MORE_ENTRIES)) {
2551                 dptr_SeekDir(dirptr, prev_dirpos);
2552                 return status;
2553         }
2554         if (!NT_STATUS_IS_OK(status)) {
2555                 return status;
2556         }
2557
2558         *_last_entry_off = last_entry_off;
2559         return NT_STATUS_OK;
2560 }
2561
2562 static NTSTATUS get_lanman2_dir_entry(TALLOC_CTX *ctx,
2563                                 connection_struct *conn,
2564                                 struct dptr_struct *dirptr,
2565                                 uint16_t flags2,
2566                                 const char *path_mask,
2567                                 uint32_t dirtype,
2568                                 int info_level,
2569                                 bool requires_resume_key,
2570                                 bool dont_descend,
2571                                 bool ask_sharemode,
2572                                 char **ppdata,
2573                                 char *base_data,
2574                                 char *end_data,
2575                                 int space_remaining,
2576                                 bool *got_exact_match,
2577                                 int *last_entry_off,
2578                                 struct ea_list *name_list)
2579 {
2580         uint8_t align = 4;
2581         const bool do_pad = true;
2582
2583         if (info_level >= 1 && info_level <= 3) {
2584                 /* No alignment on earlier info levels. */
2585                 align = 1;
2586         }
2587
2588         return smbd_dirptr_lanman2_entry(ctx, conn, dirptr, flags2,
2589                                          path_mask, dirtype, info_level,
2590                                          requires_resume_key, dont_descend, ask_sharemode,
2591                                          align, do_pad,
2592                                          ppdata, base_data, end_data,
2593                                          space_remaining,
2594                                          got_exact_match,
2595                                          last_entry_off, name_list, NULL);
2596 }
2597
2598 /****************************************************************************
2599  Reply to a TRANS2_FINDFIRST.
2600 ****************************************************************************/
2601
2602 static void call_trans2findfirst(connection_struct *conn,
2603                                  struct smb_request *req,
2604                                  char **pparams, int total_params,
2605                                  char **ppdata, int total_data,
2606                                  unsigned int max_data_bytes)
2607 {
2608         /* We must be careful here that we don't return more than the
2609                 allowed number of data bytes. If this means returning fewer than
2610                 maxentries then so be it. We assume that the redirector has
2611                 enough room for the fixed number of parameter bytes it has
2612                 requested. */
2613         struct smb_filename *smb_dname = NULL;
2614         char *params = *pparams;
2615         char *pdata = *ppdata;
2616         char *data_end;
2617         uint32_t dirtype;
2618         int maxentries;
2619         uint16_t findfirst_flags;
2620         bool close_after_first;
2621         bool close_if_end;
2622         bool requires_resume_key;
2623         int info_level;
2624         char *directory = NULL;
2625         char *mask = NULL;
2626         char *p;
2627         int last_entry_off=0;
2628         int dptr_num = -1;
2629         int numentries = 0;
2630         int i;
2631         bool finished = False;
2632         bool dont_descend = False;
2633         bool out_of_space = False;
2634         int space_remaining;
2635         bool mask_contains_wcard = False;
2636         struct ea_list *ea_list = NULL;
2637         NTSTATUS ntstatus = NT_STATUS_OK;
2638         bool ask_sharemode = lp_parm_bool(SNUM(conn), "smbd", "search ask sharemode", true);
2639         struct dptr_struct *dirptr = NULL;
2640         struct smbd_server_connection *sconn = req->sconn;
2641         uint32_t ucf_flags = UCF_SAVE_LCOMP | UCF_ALWAYS_ALLOW_WCARD_LCOMP |
2642                         ucf_flags_from_smb_request(req);
2643         bool backup_priv = false;
2644         bool as_root = false;
2645
2646         if (total_params < 13) {
2647                 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
2648                 goto out;
2649         }
2650
2651         dirtype = SVAL(params,0);
2652         maxentries = SVAL(params,2);
2653         findfirst_flags = SVAL(params,4);
2654         close_after_first = (findfirst_flags & FLAG_TRANS2_FIND_CLOSE);
2655         close_if_end = (findfirst_flags & FLAG_TRANS2_FIND_CLOSE_IF_END);
2656         requires_resume_key = (findfirst_flags & FLAG_TRANS2_FIND_REQUIRE_RESUME);
2657         backup_priv = ((findfirst_flags & FLAG_TRANS2_FIND_BACKUP_INTENT) &&
2658                                 security_token_has_privilege(get_current_nttok(conn),
2659                                                 SEC_PRIV_BACKUP));
2660
2661         info_level = SVAL(params,6);
2662
2663         DEBUG(3,("call_trans2findfirst: dirtype = %x, maxentries = %d, close_after_first=%d, \
2664 close_if_end = %d requires_resume_key = %d backup_priv = %d level = 0x%x, max_data_bytes = %d\n",
2665                 (unsigned int)dirtype, maxentries, close_after_first, close_if_end, requires_resume_key,
2666                 (int)backup_priv,
2667                 info_level, max_data_bytes));
2668
2669         if (!maxentries) {
2670                 /* W2K3 seems to treat zero as 1. */
2671                 maxentries = 1;
2672         }
2673
2674         switch (info_level) {
2675                 case SMB_FIND_INFO_STANDARD:
2676                 case SMB_FIND_EA_SIZE:
2677                 case SMB_FIND_EA_LIST:
2678                 case SMB_FIND_FILE_DIRECTORY_INFO:
2679                 case SMB_FIND_FILE_FULL_DIRECTORY_INFO:
2680                 case SMB_FIND_FILE_NAMES_INFO:
2681                 case SMB_FIND_FILE_BOTH_DIRECTORY_INFO:
2682                 case SMB_FIND_ID_FULL_DIRECTORY_INFO:
2683                 case SMB_FIND_ID_BOTH_DIRECTORY_INFO:
2684                         break;
2685                 case SMB_FIND_FILE_UNIX:
2686                 case SMB_FIND_FILE_UNIX_INFO2:
2687                         /* Always use filesystem for UNIX mtime query. */
2688                         ask_sharemode = false;
2689                         if (!lp_unix_extensions()) {
2690                                 reply_nterror(req, NT_STATUS_INVALID_LEVEL);
2691                                 goto out;
2692                         }
2693                         ucf_flags |= UCF_UNIX_NAME_LOOKUP;
2694                         break;
2695                 default:
2696                         reply_nterror(req, NT_STATUS_INVALID_LEVEL);
2697                         goto out;
2698         }
2699
2700         if (req->posix_pathnames) {
2701                 srvstr_get_path_wcard_posix(talloc_tos(),
2702                                 params,
2703                                 req->flags2,
2704                                 &directory,
2705                                 params+12,
2706                                 total_params - 12,
2707                                 STR_TERMINATE,
2708                                 &ntstatus,
2709                                 &mask_contains_wcard);
2710         } else {
2711                 srvstr_get_path_wcard(talloc_tos(),
2712                                 params,
2713                                 req->flags2,
2714                                 &directory,
2715                                 params+12,
2716                                 total_params - 12,
2717                                 STR_TERMINATE,
2718                                 &ntstatus,
2719                                 &mask_contains_wcard);
2720         }
2721         if (!NT_STATUS_IS_OK(ntstatus)) {
2722                 reply_nterror(req, ntstatus);
2723                 goto out;
2724         }
2725
2726         if (backup_priv) {
2727                 become_root();
2728                 as_root = true;
2729                 ntstatus = filename_convert_with_privilege(talloc_tos(),
2730                                 conn,
2731                                 req,
2732                                 directory,
2733                                 ucf_flags,
2734                                 &mask_contains_wcard,
2735                                 &smb_dname);
2736         } else {
2737                 ntstatus = filename_convert(talloc_tos(), conn,
2738                                     directory,
2739                                     ucf_flags,
2740                                     &mask_contains_wcard,
2741                                     &smb_dname);
2742         }
2743
2744         if (!NT_STATUS_IS_OK(ntstatus)) {
2745                 if (NT_STATUS_EQUAL(ntstatus,NT_STATUS_PATH_NOT_COVERED)) {
2746                         reply_botherror(req, NT_STATUS_PATH_NOT_COVERED,
2747                                         ERRSRV, ERRbadpath);
2748                         goto out;
2749                 }
2750                 reply_nterror(req, ntstatus);
2751                 goto out;
2752         }
2753
2754         mask = smb_dname->original_lcomp;
2755
2756         directory = smb_dname->base_name;
2757
2758         p = strrchr_m(directory,'/');
2759         if(p == NULL) {
2760                 /* Windows and OS/2 systems treat search on the root '\' as if it were '\*' */
2761                 if((directory[0] == '.') && (directory[1] == '\0')) {
2762                         mask = talloc_strdup(talloc_tos(),"*");
2763                         if (!mask) {
2764                                 reply_nterror(req, NT_STATUS_NO_MEMORY);
2765                                 goto out;
2766                         }
2767                         mask_contains_wcard = True;
2768                 }
2769         } else {
2770                 *p = 0;
2771         }
2772
2773         if (p == NULL || p == directory) {
2774                 /* Ensure we don't have a directory name of "". */
2775                 directory = talloc_strdup(talloc_tos(), ".");
2776                 if (!directory) {
2777                         reply_nterror(req, NT_STATUS_NO_MEMORY);
2778                         goto out;
2779                 }
2780                 /* Ensure smb_dname->base_name matches. */
2781                 smb_dname->base_name = directory;
2782         }
2783
2784         DEBUG(5,("dir=%s, mask = %s\n",directory, mask));
2785
2786         if (info_level == SMB_FIND_EA_LIST) {
2787                 uint32_t ea_size;
2788
2789                 if (total_data < 4) {
2790                         reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
2791                         goto out;
2792                 }
2793
2794                 ea_size = IVAL(pdata,0);
2795                 if (ea_size != total_data) {
2796                         DEBUG(4,("call_trans2findfirst: Rejecting EA request with incorrect \
2797 total_data=%u (should be %u)\n", (unsigned int)total_data, (unsigned int)IVAL(pdata,0) ));
2798                         reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
2799                         goto out;
2800                 }
2801
2802                 if (!lp_ea_support(SNUM(conn))) {
2803                         reply_nterror(req, NT_STATUS_EAS_NOT_SUPPORTED);
2804                         goto out;
2805                 }
2806
2807                 /* Pull out the list of names. */
2808                 ea_list = read_ea_name_list(talloc_tos(), pdata + 4, ea_size - 4);
2809                 if (!ea_list) {
2810                         reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
2811                         goto out;
2812                 }
2813         }
2814
2815         if (max_data_bytes + DIR_ENTRY_SAFETY_MARGIN < max_data_bytes) {
2816                 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
2817                 goto out;
2818         }
2819
2820         *ppdata = (char *)SMB_REALLOC(
2821                 *ppdata, max_data_bytes + DIR_ENTRY_SAFETY_MARGIN);
2822         if(*ppdata == NULL ) {
2823                 reply_nterror(req, NT_STATUS_NO_MEMORY);
2824                 goto out;
2825         }
2826         pdata = *ppdata;
2827         data_end = pdata + max_data_bytes + DIR_ENTRY_SAFETY_MARGIN - 1;
2828         /*
2829          * squash valgrind "writev(vector[...]) points to uninitialised byte(s)"
2830          * error.
2831          */
2832         memset(pdata + total_data, 0, ((max_data_bytes + DIR_ENTRY_SAFETY_MARGIN) - total_data));
2833         /* Realloc the params space */
2834         *pparams = (char *)SMB_REALLOC(*pparams, 10);
2835         if (*pparams == NULL) {
2836                 reply_nterror(req, NT_STATUS_NO_MEMORY);
2837                 goto out;
2838         }
2839         params = *pparams;
2840
2841         /* Save the wildcard match and attribs we are using on this directory -
2842                 needed as lanman2 assumes these are being saved between calls */
2843
2844         ntstatus = dptr_create(conn,
2845                                 req,
2846                                 NULL, /* fsp */
2847                                 smb_dname,
2848                                 False,
2849                                 True,
2850                                 req->smbpid,
2851                                 mask,
2852                                 mask_contains_wcard,
2853                                 dirtype,
2854                                 &dirptr);
2855
2856         if (!NT_STATUS_IS_OK(ntstatus)) {
2857                 reply_nterror(req, ntstatus);
2858                 goto out;
2859         }
2860
2861         if (backup_priv) {
2862                 /* Remember this in case we have
2863                    to do a findnext. */
2864                 dptr_set_priv(dirptr);
2865         }
2866
2867         dptr_num = dptr_dnum(dirptr);
2868         DEBUG(4,("dptr_num is %d, wcard = %s, attr = %d\n", dptr_num, mask, dirtype));
2869
2870         /* Initialize per TRANS2_FIND_FIRST operation data */
2871         dptr_init_search_op(dirptr);
2872
2873         /* We don't need to check for VOL here as this is returned by
2874                 a different TRANS2 call. */
2875
2876         DEBUG(8,("dirpath=<%s> dontdescend=<%s>\n",
2877                  directory,lp_dont_descend(talloc_tos(), SNUM(conn))));
2878         if (in_list(directory,
2879                         lp_dont_descend(talloc_tos(), SNUM(conn)),
2880                         conn->case_sensitive)) {
2881                 dont_descend = True;
2882         }
2883
2884         p = pdata;
2885         space_remaining = max_data_bytes;
2886         out_of_space = False;
2887
2888         for (i=0;(i<maxentries) && !finished && !out_of_space;i++) {
2889                 bool got_exact_match = False;
2890
2891                 /* this is a heuristic to avoid seeking the dirptr except when
2892                         absolutely necessary. It allows for a filename of about 40 chars */
2893                 if (space_remaining < DIRLEN_GUESS && numentries > 0) {
2894                         out_of_space = True;
2895                         finished = False;
2896                 } else {
2897                         ntstatus = get_lanman2_dir_entry(talloc_tos(),
2898                                         conn,
2899                                         dirptr,
2900                                         req->flags2,
2901                                         mask,dirtype,info_level,
2902                                         requires_resume_key,dont_descend,
2903                                         ask_sharemode,
2904                                         &p,pdata,data_end,
2905                                         space_remaining,
2906                                         &got_exact_match,
2907                                         &last_entry_off, ea_list);
2908                         if (NT_STATUS_EQUAL(ntstatus,
2909                                         NT_STATUS_ILLEGAL_CHARACTER)) {
2910                                 /*
2911                                  * Bad character conversion on name. Ignore this
2912                                  * entry.
2913                                  */
2914                                 continue;
2915                         }
2916                         if (NT_STATUS_EQUAL(ntstatus, STATUS_MORE_ENTRIES)) {
2917                                 out_of_space = true;
2918                         } else {
2919                                 finished = !NT_STATUS_IS_OK(ntstatus);
2920                         }
2921                 }
2922
2923                 if (!finished && !out_of_space)
2924                         numentries++;
2925
2926                 /*
2927                  * As an optimisation if we know we aren't looking
2928                  * for a wildcard name (ie. the name matches the wildcard exactly)
2929                  * then we can finish on any (first) match.
2930                  * This speeds up large directory searches. JRA.
2931                  */
2932
2933                 if(got_exact_match)
2934                         finished = True;
2935
2936                 /* Ensure space_remaining never goes -ve. */
2937                 if (PTR_DIFF(p,pdata) > max_data_bytes) {
2938                         space_remaining = 0;
2939                         out_of_space = true;
2940                 } else {
2941                         space_remaining = max_data_bytes - PTR_DIFF(p,pdata);
2942                 }
2943         }
2944
2945         /* Check if we can close the dirptr */
2946         if(close_after_first || (finished && close_if_end)) {
2947                 DEBUG(5,("call_trans2findfirst - (2) closing dptr_num %d\n", dptr_num));
2948                 dptr_close(sconn, &dptr_num);
2949         }
2950
2951         /*
2952          * If there are no matching entries we must return ERRDOS/ERRbadfile -
2953          * from observation of NT. NB. This changes to ERRDOS,ERRnofiles if
2954          * the protocol level is less than NT1. Tested with smbclient. JRA.
2955          * This should fix the OS/2 client bug #2335.
2956          */
2957
2958         if(numentries == 0) {
2959                 dptr_close(sconn, &dptr_num);
2960                 if (get_Protocol() < PROTOCOL_NT1) {
2961                         reply_force_doserror(req, ERRDOS, ERRnofiles);
2962                         goto out;
2963                 } else {
2964                         reply_botherror(req, NT_STATUS_NO_SUCH_FILE,
2965                                         ERRDOS, ERRbadfile);
2966                         goto out;
2967                 }
2968         }
2969
2970         /* At this point pdata points to numentries directory entries. */
2971
2972         /* Set up the return parameter block */
2973         SSVAL(params,0,dptr_num);
2974         SSVAL(params,2,numentries);
2975         SSVAL(params,4,finished);
2976         SSVAL(params,6,0); /* Never an EA error */
2977         SSVAL(params,8,last_entry_off);
2978
2979         send_trans2_replies(conn, req, NT_STATUS_OK, params, 10, pdata, PTR_DIFF(p,pdata),
2980                             max_data_bytes);
2981
2982         if ((! *directory) && dptr_path(sconn, dptr_num)) {
2983                 directory = talloc_strdup(talloc_tos(),dptr_path(sconn, dptr_num));
2984                 if (!directory) {
2985                         reply_nterror(req, NT_STATUS_NO_MEMORY);
2986                 }
2987         }
2988
2989         DEBUG( 4, ( "%s mask=%s directory=%s dirtype=%d numentries=%d\n",
2990                 smb_fn_name(req->cmd),
2991                 mask, directory, dirtype, numentries ) );
2992
2993         /*
2994          * Force a name mangle here to ensure that the
2995          * mask as an 8.3 name is top of the mangled cache.
2996          * The reasons for this are subtle. Don't remove
2997          * this code unless you know what you are doing
2998          * (see PR#13758). JRA.
2999          */
3000
3001         if(!mangle_is_8_3_wildcards( mask, False, conn->params)) {
3002                 char mangled_name[13];
3003                 name_to_8_3(mask, mangled_name, True, conn->params);
3004         }
3005  out:
3006
3007         if (as_root) {
3008                 unbecome_root();
3009         }
3010
3011         TALLOC_FREE(smb_dname);
3012         return;
3013 }
3014
3015 /****************************************************************************
3016  Reply to a TRANS2_FINDNEXT.
3017 ****************************************************************************/
3018
3019 static void call_trans2findnext(connection_struct *conn,
3020                                 struct smb_request *req,
3021                                 char **pparams, int total_params,
3022                                 char **ppdata, int total_data,
3023                                 unsigned int max_data_bytes)
3024 {
3025         /* We must be careful here that we don't return more than the
3026                 allowed number of data bytes. If this means returning fewer than
3027                 maxentries then so be it. We assume that the redirector has
3028                 enough room for the fixed number of parameter bytes it has
3029                 requested. */
3030         char *params = *pparams;
3031         char *pdata = *ppdata;
3032         char *data_end;
3033         int dptr_num;
3034         int maxentries;
3035         uint16_t info_level;
3036         uint32_t resume_key;
3037         uint16_t findnext_flags;
3038         bool close_after_request;
3039         bool close_if_end;
3040         bool requires_resume_key;
3041         bool continue_bit;
3042         bool mask_contains_wcard = False;
3043         char *resume_name = NULL;
3044         const char *mask = NULL;
3045         const char *directory = NULL;
3046         char *p = NULL;
3047         uint16_t dirtype;
3048         int numentries = 0;
3049         int i, last_entry_off=0;
3050         bool finished = False;
3051         bool dont_descend = False;
3052         bool out_of_space = False;
3053         int space_remaining;
3054         struct ea_list *ea_list = NULL;
3055         NTSTATUS ntstatus = NT_STATUS_OK;
3056         bool ask_sharemode = lp_parm_bool(SNUM(conn), "smbd", "search ask sharemode", true);
3057         TALLOC_CTX *ctx = talloc_tos();
3058         struct dptr_struct *dirptr;
3059         struct smbd_server_connection *sconn = req->sconn;
3060         bool backup_priv = false;
3061         bool as_root = false;
3062
3063         if (total_params < 13) {
3064                 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
3065                 return;
3066         }
3067
3068         dptr_num = SVAL(params,0);
3069         maxentries = SVAL(params,2);
3070         info_level = SVAL(params,4);
3071         resume_key = IVAL(params,6);
3072         findnext_flags = SVAL(params,10);
3073         close_after_request = (findnext_flags & FLAG_TRANS2_FIND_CLOSE);
3074         close_if_end = (findnext_flags & FLAG_TRANS2_FIND_CLOSE_IF_END);
3075         requires_resume_key = (findnext_flags & FLAG_TRANS2_FIND_REQUIRE_RESUME);
3076         continue_bit = (findnext_flags & FLAG_TRANS2_FIND_CONTINUE);
3077
3078         if (!continue_bit) {
3079                 /* We only need resume_name if continue_bit is zero. */
3080                 if (req->posix_pathnames) {
3081                         srvstr_get_path_wcard_posix(ctx,
3082                                 params,
3083                                 req->flags2,
3084                                 &resume_name,
3085                                 params+12,
3086                                 total_params - 12,
3087                                 STR_TERMINATE,
3088                                 &ntstatus,
3089                                 &mask_contains_wcard);
3090                 } else {
3091                         srvstr_get_path_wcard(ctx,
3092                                 params,
3093                                 req->flags2,
3094                                 &resume_name,
3095                                 params+12,
3096                                 total_params - 12,
3097                                 STR_TERMINATE,
3098                                 &ntstatus,
3099                                 &mask_contains_wcard);
3100                 }
3101                 if (!NT_STATUS_IS_OK(ntstatus)) {
3102                         /* Win9x or OS/2 can send a resume name of ".." or ".". This will cause the parser to
3103                            complain (it thinks we're asking for the directory above the shared
3104                            path or an invalid name). Catch this as the resume name is only compared, never used in
3105                            a file access. JRA. */
3106                         srvstr_pull_talloc(ctx, params, req->flags2,
3107                                 &resume_name, params+12,
3108                                 total_params - 12,
3109                                 STR_TERMINATE);
3110
3111                         if (!resume_name || !(ISDOT(resume_name) || ISDOTDOT(resume_name))) {
3112                                 reply_nterror(req, ntstatus);
3113                                 return;
3114                         }
3115                 }
3116         }
3117
3118         DEBUG(3,("call_trans2findnext: dirhandle = %d, max_data_bytes = %d, maxentries = %d, \
3119 close_after_request=%d, close_if_end = %d requires_resume_key = %d \
3120 resume_key = %d resume name = %s continue=%d level = %d\n",
3121                 dptr_num, max_data_bytes, maxentries, close_after_request, close_if_end,
3122                 requires_resume_key, resume_key,
3123                 resume_name ? resume_name : "(NULL)", continue_bit, info_level));
3124
3125         if (!maxentries) {
3126                 /* W2K3 seems to treat zero as 1. */
3127                 maxentries = 1;
3128         }
3129
3130         switch (info_level) {
3131                 case SMB_FIND_INFO_STANDARD:
3132                 case SMB_FIND_EA_SIZE:
3133                 case SMB_FIND_EA_LIST:
3134                 case SMB_FIND_FILE_DIRECTORY_INFO:
3135                 case SMB_FIND_FILE_FULL_DIRECTORY_INFO:
3136                 case SMB_FIND_FILE_NAMES_INFO:
3137                 case SMB_FIND_FILE_BOTH_DIRECTORY_INFO:
3138                 case SMB_FIND_ID_FULL_DIRECTORY_INFO:
3139                 case SMB_FIND_ID_BOTH_DIRECTORY_INFO:
3140                         break;
3141                 case SMB_FIND_FILE_UNIX:
3142                 case SMB_FIND_FILE_UNIX_INFO2:
3143                         /* Always use filesystem for UNIX mtime query. */
3144                         ask_sharemode = false;
3145                         if (!lp_unix_extensions()) {
3146                                 reply_nterror(req, NT_STATUS_INVALID_LEVEL);
3147                                 return;
3148                         }
3149                         break;
3150                 default:
3151                         reply_nterror(req, NT_STATUS_INVALID_LEVEL);
3152                         return;
3153         }
3154
3155         if (info_level == SMB_FIND_EA_LIST) {
3156                 uint32_t ea_size;
3157
3158                 if (total_data < 4) {
3159                         reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
3160                         return;
3161                 }
3162
3163                 ea_size = IVAL(pdata,0);
3164                 if (ea_size != total_data) {
3165                         DEBUG(4,("call_trans2findnext: Rejecting EA request with incorrect \
3166 total_data=%u (should be %u)\n", (unsigned int)total_data, (unsigned int)IVAL(pdata,0) ));
3167                         reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
3168                         return;
3169                 }
3170
3171                 if (!lp_ea_support(SNUM(conn))) {
3172                         reply_nterror(req, NT_STATUS_EAS_NOT_SUPPORTED);
3173                         return;
3174                 }
3175
3176                 /* Pull out the list of names. */
3177                 ea_list = read_ea_name_list(ctx, pdata + 4, ea_size - 4);
3178                 if (!ea_list) {
3179                         reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
3180                         return;
3181                 }
3182         }
3183
3184         if (max_data_bytes + DIR_ENTRY_SAFETY_MARGIN < max_data_bytes) {
3185                 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
3186                 return;
3187         }
3188
3189         *ppdata = (char *)SMB_REALLOC(
3190                 *ppdata, max_data_bytes + DIR_ENTRY_SAFETY_MARGIN);
3191         if(*ppdata == NULL) {
3192                 reply_nterror(req, NT_STATUS_NO_MEMORY);
3193                 return;
3194         }
3195
3196         pdata = *ppdata;
3197         data_end = pdata + max_data_bytes + DIR_ENTRY_SAFETY_MARGIN - 1;
3198
3199         /*
3200          * squash valgrind "writev(vector[...]) points to uninitialised byte(s)"
3201          * error.
3202          */
3203         memset(pdata + total_data, 0, (max_data_bytes + DIR_ENTRY_SAFETY_MARGIN) - total_data);
3204         /* Realloc the params space */
3205         *pparams = (char *)SMB_REALLOC(*pparams, 6*SIZEOFWORD);
3206         if(*pparams == NULL ) {
3207                 reply_nterror(req, NT_STATUS_NO_MEMORY);
3208                 return;
3209         }
3210
3211         params = *pparams;
3212
3213         /* Check that the dptr is valid */
3214         if(!(dirptr = dptr_fetch_lanman2(sconn, dptr_num))) {
3215                 reply_nterror(req, STATUS_NO_MORE_FILES);
3216                 return;
3217         }
3218
3219         directory = dptr_path(sconn, dptr_num);
3220
3221         /* Get the wildcard mask from the dptr */
3222         if((mask = dptr_wcard(sconn, dptr_num))== NULL) {
3223                 DEBUG(2,("dptr_num %d has no wildcard\n", dptr_num));
3224                 reply_nterror(req, STATUS_NO_MORE_FILES);
3225                 return;
3226         }
3227
3228         /* Get the attr mask from the dptr */
3229         dirtype = dptr_attr(sconn, dptr_num);
3230
3231         backup_priv = dptr_get_priv(dirptr);
3232
3233         DEBUG(3,("dptr_num is %d, mask = %s, attr = %x, dirptr=(0x%lX,%ld) "
3234                 "backup_priv = %d\n",
3235                 dptr_num, mask, dirtype,
3236                 (long)dirptr,
3237                 dptr_TellDir(dirptr),
3238                 (int)backup_priv));
3239
3240         /* Initialize per TRANS2_FIND_NEXT operation data */
3241         dptr_init_search_op(dirptr);
3242
3243         /* We don't need to check for VOL here as this is returned by
3244                 a different TRANS2 call. */
3245
3246         DEBUG(8,("dirpath=<%s> dontdescend=<%s>\n",
3247                  directory,lp_dont_descend(ctx, SNUM(conn))));
3248         if (in_list(directory,lp_dont_descend(ctx, SNUM(conn)),conn->case_sensitive))
3249                 dont_descend = True;
3250
3251         p = pdata;
3252         space_remaining = max_data_bytes;
3253         out_of_space = False;
3254
3255         if (backup_priv) {
3256                 become_root();
3257                 as_root = true;
3258         }
3259
3260         /*
3261          * Seek to the correct position. We no longer use the resume key but
3262          * depend on the last file name instead.
3263          */
3264
3265         if(!continue_bit && resume_name && *resume_name) {
3266                 SMB_STRUCT_STAT st;
3267
3268                 long current_pos = 0;
3269                 /*
3270                  * Remember, name_to_8_3 is called by
3271                  * get_lanman2_dir_entry(), so the resume name
3272                  * could be mangled. Ensure we check the unmangled name.
3273                  */
3274
3275                 if (mangle_is_mangled(resume_name, conn->params)) {
3276                         char *new_resume_name = NULL;
3277                         mangle_lookup_name_from_8_3(ctx,
3278                                                 resume_name,
3279                                                 &new_resume_name,
3280                                                 conn->params);
3281                         if (new_resume_name) {
3282                                 resume_name = new_resume_name;
3283                         }
3284                 }
3285
3286                 /*
3287                  * Fix for NT redirector problem triggered by resume key indexes
3288                  * changing between directory scans. We now return a resume key of 0
3289                  * and instead look for the filename to continue from (also given
3290                  * to us by NT/95/smbfs/smbclient). If no other scans have been done between the
3291                  * findfirst/findnext (as is usual) then the directory pointer
3292                  * should already be at the correct place.
3293                  */
3294
3295                 finished = !dptr_SearchDir(dirptr, resume_name, &current_pos, &st);
3296         } /* end if resume_name && !continue_bit */
3297
3298         for (i=0;(i<(int)maxentries) && !finished && !out_of_space ;i++) {
3299                 bool got_exact_match = False;
3300
3301                 /* this is a heuristic to avoid seeking the dirptr except when
3302                         absolutely necessary. It allows for a filename of about 40 chars */
3303                 if (space_remaining < DIRLEN_GUESS && numentries > 0) {
3304                         out_of_space = True;
3305                         finished = False;
3306                 } else {
3307                         ntstatus = get_lanman2_dir_entry(ctx,
3308                                                 conn,
3309                                                 dirptr,
3310                                                 req->flags2,
3311                                                 mask,dirtype,info_level,
3312                                                 requires_resume_key,dont_descend,
3313                                                 ask_sharemode,
3314                                                 &p,pdata,data_end,
3315                                                 space_remaining,
3316                                                 &got_exact_match,
3317                                                 &last_entry_off, ea_list);
3318                         if (NT_STATUS_EQUAL(ntstatus,
3319                                         NT_STATUS_ILLEGAL_CHARACTER)) {
3320                                 /*
3321                                  * Bad character conversion on name. Ignore this
3322                                  * entry.
3323                                  */
3324                                 continue;
3325                         }
3326                         if (NT_STATUS_EQUAL(ntstatus, STATUS_MORE_ENTRIES)) {
3327                                 out_of_space = true;
3328                         } else {
3329                                 finished = !NT_STATUS_IS_OK(ntstatus);
3330                         }
3331                 }
3332
3333                 if (!finished && !out_of_space)
3334                         numentries++;
3335
3336                 /*
3337                  * As an optimisation if we know we aren't looking
3338                  * for a wildcard name (ie. the name matches the wildcard exactly)
3339                  * then we can finish on any (first) match.
3340                  * This speeds up large directory searches. JRA.
3341                  */
3342
3343                 if(got_exact_match)
3344                         finished = True;
3345
3346                 space_remaining = max_data_bytes - PTR_DIFF(p,pdata);
3347         }
3348
3349         DEBUG( 3, ( "%s mask=%s directory=%s dirtype=%d numentries=%d\n",
3350                 smb_fn_name(req->cmd),
3351                 mask, directory, dirtype, numentries ) );
3352
3353         /* Check if we can close the dirptr */
3354         if(close_after_request || (finished && close_if_end)) {
3355                 DEBUG(5,("call_trans2findnext: closing dptr_num = %d\n", dptr_num));
3356                 dptr_close(sconn, &dptr_num); /* This frees up the saved mask */
3357         }
3358
3359         if (as_root) {
3360                 unbecome_root();
3361         }
3362
3363         /* Set up the return parameter block */
3364         SSVAL(params,0,numentries);
3365         SSVAL(params,2,finished);
3366         SSVAL(params,4,0); /* Never an EA error */
3367         SSVAL(params,6,last_entry_off);
3368
3369         send_trans2_replies(conn, req, NT_STATUS_OK, params, 8, pdata, PTR_DIFF(p,pdata),
3370                             max_data_bytes);
3371
3372         return;
3373 }
3374
3375 unsigned char *create_volume_objectid(connection_struct *conn, unsigned char objid[16])
3376 {
3377         E_md4hash(lp_servicename(talloc_tos(), SNUM(conn)),objid);
3378         return objid;
3379 }
3380
3381 static void samba_extended_info_version(struct smb_extended_info *extended_info)
3382 {
3383         SMB_ASSERT(extended_info != NULL);
3384
3385         extended_info->samba_magic = SAMBA_EXTENDED_INFO_MAGIC;
3386         extended_info->samba_version = ((SAMBA_VERSION_MAJOR & 0xff) << 24)
3387                                        | ((SAMBA_VERSION_MINOR & 0xff) << 16)
3388                                        | ((SAMBA_VERSION_RELEASE & 0xff) << 8);
3389 #ifdef SAMBA_VERSION_REVISION
3390         extended_info->samba_version |= (tolower(*SAMBA_VERSION_REVISION) - 'a' + 1) & 0xff;
3391 #endif
3392         extended_info->samba_subversion = 0;
3393 #ifdef SAMBA_VERSION_RC_RELEASE
3394         extended_info->samba_subversion |= (SAMBA_VERSION_RC_RELEASE & 0xff) << 24;
3395 #else
3396 #ifdef SAMBA_VERSION_PRE_RELEASE
3397         extended_info->samba_subversion |= (SAMBA_VERSION_PRE_RELEASE & 0xff) << 16;
3398 #endif
3399 #endif
3400 #ifdef SAMBA_VERSION_VENDOR_PATCH
3401         extended_info->samba_subversion |= (SAMBA_VERSION_VENDOR_PATCH & 0xffff);
3402 #endif
3403         extended_info->samba_gitcommitdate = 0;
3404 #ifdef SAMBA_VERSION_COMMIT_TIME
3405         unix_to_nt_time(&extended_info->samba_gitcommitdate, SAMBA_VERSION_COMMIT_TIME);
3406 #endif
3407
3408         memset(extended_info->samba_version_string, 0,
3409                sizeof(extended_info->samba_version_string));
3410
3411         snprintf (extended_info->samba_version_string,
3412                   sizeof(extended_info->samba_version_string),
3413                   "%s", samba_version_string());
3414 }
3415
3416 NTSTATUS smbd_do_qfsinfo(struct smbXsrv_connection *xconn,
3417                          connection_struct *conn,
3418                          TALLOC_CTX *mem_ctx,
3419                          uint16_t info_level,
3420                          uint16_t flags2,
3421                          unsigned int max_data_bytes,
3422                          size_t *fixed_portion,
3423                          struct smb_filename *fname,
3424                          char **ppdata,
3425                          int *ret_data_len)
3426 {
3427         char *pdata, *end_data;
3428         int data_len = 0;
3429         size_t len = 0;
3430         const char *vname = volume_label(talloc_tos(), SNUM(conn));
3431         int snum = SNUM(conn);
3432         const char *fstype = lp_fstype(SNUM(conn));
3433         const char *filename = NULL;
3434         const uint64_t bytes_per_sector = 512;
3435         uint32_t additional_flags = 0;
3436         struct smb_filename smb_fname;
3437         SMB_STRUCT_STAT st;
3438         NTSTATUS status = NT_STATUS_OK;
3439         uint64_t df_ret;
3440
3441         if (fname == NULL || fname->base_name == NULL) {
3442                 filename = ".";
3443         } else {
3444                 filename = fname->base_name;
3445         }
3446
3447         if (IS_IPC(conn)) {
3448                 if (info_level != SMB_QUERY_CIFS_UNIX_INFO) {
3449                         DEBUG(0,("smbd_do_qfsinfo: not an allowed "
3450                                 "info level (0x%x) on IPC$.\n",
3451                                 (unsigned int)info_level));
3452                         return NT_STATUS_ACCESS_DENIED;
3453                 }
3454         }
3455
3456         DEBUG(3,("smbd_do_qfsinfo: level = %d\n", info_level));
3457
3458         ZERO_STRUCT(smb_fname);
3459         smb_fname.base_name = discard_const_p(char, filename);
3460
3461         if(SMB_VFS_STAT(conn, &smb_fname) != 0) {
3462                 DEBUG(2,("stat of . failed (%s)\n", strerror(errno)));
3463                 return map_nt_error_from_unix(errno);
3464         }
3465
3466         st = smb_fname.st;
3467
3468         if (max_data_bytes + DIR_ENTRY_SAFETY_MARGIN < max_data_bytes) {
3469                 return NT_STATUS_INVALID_PARAMETER;
3470         }
3471
3472         *ppdata = (char *)SMB_REALLOC(
3473                 *ppdata, max_data_bytes + DIR_ENTRY_SAFETY_MARGIN);
3474         if (*ppdata == NULL) {
3475                 return NT_STATUS_NO_MEMORY;
3476         }
3477
3478         pdata = *ppdata;
3479         memset((char *)pdata,'\0',max_data_bytes + DIR_ENTRY_SAFETY_MARGIN);
3480         end_data = pdata + max_data_bytes + DIR_ENTRY_SAFETY_MARGIN - 1;
3481
3482         *fixed_portion = 0;
3483
3484         switch (info_level) {
3485                 case SMB_INFO_ALLOCATION:
3486                 {
3487                         uint64_t dfree,dsize,bsize,block_size,sectors_per_unit;
3488                         data_len = 18;
3489                         df_ret = get_dfree_info(conn, &smb_fname, &bsize,
3490                                                 &dfree, &dsize);
3491                         if (df_ret == (uint64_t)-1) {
3492                                 return map_nt_error_from_unix(errno);
3493                         }
3494
3495                         block_size = lp_block_size(snum);
3496                         if (bsize < block_size) {
3497                                 uint64_t factor = block_size/bsize;
3498                                 bsize = block_size;
3499                                 dsize /= factor;
3500                                 dfree /= factor;
3501                         }
3502                         if (bsize > block_size) {
3503                                 uint64_t factor = bsize/block_size;
3504                                 bsize = block_size;
3505                                 dsize *= factor;
3506                                 dfree *= factor;
3507                         }
3508                         sectors_per_unit = bsize/bytes_per_sector;
3509
3510                         DEBUG(5,("smbd_do_qfsinfo : SMB_INFO_ALLOCATION id=%x, bsize=%u, cSectorUnit=%u, \
3511 cBytesSector=%u, cUnitTotal=%u, cUnitAvail=%d\n", (unsigned int)st.st_ex_dev, (unsigned int)bsize, (unsigned int)sectors_per_unit,
3512                                 (unsigned int)bytes_per_sector, (unsigned int)dsize, (unsigned int)dfree));
3513
3514                         /*
3515                          * For large drives, return max values and not modulo.
3516                          */
3517                         dsize = MIN(dsize, UINT32_MAX);
3518                         dfree = MIN(dfree, UINT32_MAX);
3519
3520                         SIVAL(pdata,l1_idFileSystem,st.st_ex_dev);
3521                         SIVAL(pdata,l1_cSectorUnit,sectors_per_unit);
3522                         SIVAL(pdata,l1_cUnit,dsize);
3523                         SIVAL(pdata,l1_cUnitAvail,dfree);
3524                         SSVAL(pdata,l1_cbSector,bytes_per_sector);
3525                         break;
3526                 }
3527
3528                 case SMB_INFO_VOLUME:
3529                         /* Return volume name */
3530                         /*
3531                          * Add volume serial number - hash of a combination of
3532                          * the called hostname and the service name.
3533                          */
3534                         SIVAL(pdata,0,str_checksum(lp_servicename(talloc_tos(), snum)) ^ (str_checksum(get_local_machine_name())<<16) );
3535                         /*
3536                          * Win2k3 and previous mess this up by sending a name length
3537                          * one byte short. I believe only older clients (OS/2 Win9x) use
3538                          * this call so try fixing this by adding a terminating null to
3539                          * the pushed string. The change here was adding the STR_TERMINATE. JRA.
3540                          */
3541                         status = srvstr_push(
3542                                 pdata, flags2,
3543                                 pdata+l2_vol_szVolLabel, vname,
3544                                 PTR_DIFF(end_data, pdata+l2_vol_szVolLabel),
3545                                 STR_NOALIGN|STR_TERMINATE, &len);
3546                         if (!NT_STATUS_IS_OK(status)) {
3547                                 return status;
3548                         }
3549                         SCVAL(pdata,l2_vol_cch,len);
3550                         data_len = l2_vol_szVolLabel + len;
3551                         DEBUG(5,("smbd_do_qfsinfo : time = %x, namelen = %u, name = %s\n",
3552                                  (unsigned)convert_timespec_to_time_t(st.st_ex_ctime),
3553                                  (unsigned)len, vname));
3554                         break;
3555
3556                 case SMB_QUERY_FS_ATTRIBUTE_INFO:
3557                 case SMB_FS_ATTRIBUTE_INFORMATION:
3558
3559                         additional_flags = 0;
3560 #if defined(HAVE_SYS_QUOTAS)
3561                         additional_flags |= FILE_VOLUME_QUOTAS;
3562 #endif
3563
3564                         if(lp_nt_acl_support(SNUM(conn))) {
3565                                 additional_flags |= FILE_PERSISTENT_ACLS;
3566                         }
3567
3568                         /* Capabilities are filled in at connection time through STATVFS call */
3569                         additional_flags |= conn->fs_capabilities;
3570                         additional_flags |= lp_parm_int(conn->params->service,
3571                                                         "share", "fake_fscaps",
3572                                                         0);
3573
3574                         SIVAL(pdata,0,FILE_CASE_PRESERVED_NAMES|FILE_CASE_SENSITIVE_SEARCH|
3575                                 FILE_SUPPORTS_OBJECT_IDS|FILE_UNICODE_ON_DISK|
3576                                 additional_flags); /* FS ATTRIBUTES */
3577
3578                         SIVAL(pdata,4,255); /* Max filename component length */
3579                         /* NOTE! the fstype must *not* be null terminated or win98 won't recognise it
3580                                 and will think we can't do long filenames */
3581                         status = srvstr_push(pdata, flags2, pdata+12, fstype,
3582                                           PTR_DIFF(end_data, pdata+12),
3583                                           STR_UNICODE, &len);
3584                         if (!NT_STATUS_IS_OK(status)) {
3585                                 return status;
3586                         }
3587                         SIVAL(pdata,8,len);
3588                         data_len = 12 + len;
3589                         if (max_data_bytes >= 16 && data_len > max_data_bytes) {
3590                                 /* the client only requested a portion of the
3591                                    file system name */
3592                                 data_len = max_data_bytes;
3593                                 status = STATUS_BUFFER_OVERFLOW;
3594                         }
3595                         *fixed_portion = 16;
3596                         break;
3597
3598                 case SMB_QUERY_FS_LABEL_INFO:
3599                 case SMB_FS_LABEL_INFORMATION:
3600                         status = srvstr_push(pdata, flags2, pdata+4, vname,
3601                                           PTR_DIFF(end_data, pdata+4), 0, &len);
3602                         if (!NT_STATUS_IS_OK(status)) {
3603                                 return status;
3604                         }
3605                         data_len = 4 + len;
3606                         SIVAL(pdata,0,len);
3607                         break;
3608
3609                 case SMB_QUERY_FS_VOLUME_INFO:
3610                 case SMB_FS_VOLUME_INFORMATION:
3611
3612                         /*
3613                          * Add volume serial number - hash of a combination of
3614                          * the called hostname and the service name.
3615                          */
3616                         SIVAL(pdata,8,str_checksum(lp_servicename(talloc_tos(), snum)) ^
3617                                 (str_checksum(get_local_machine_name())<<16));
3618
3619                         /* Max label len is 32 characters. */
3620                         status = srvstr_push(pdata, flags2, pdata+18, vname,
3621                                           PTR_DIFF(end_data, pdata+18),
3622                                           STR_UNICODE, &len);
3623                         if (!NT_STATUS_IS_OK(status)) {
3624                                 return status;
3625                         }
3626                         SIVAL(pdata,12,len);
3627                         data_len = 18+len;
3628
3629                         DEBUG(5,("smbd_do_qfsinfo : SMB_QUERY_FS_VOLUME_INFO namelen = %d, vol=%s serv=%s\n",
3630                                 (int)strlen(vname),vname,
3631                                 lp_servicename(talloc_tos(), snum)));
3632                         if (max_data_bytes >= 24 && data_len > max_data_bytes) {
3633                                 /* the client only requested a portion of the
3634                                    volume label */
3635                                 data_len = max_data_bytes;
3636                                 status = STATUS_BUFFER_OVERFLOW;
3637                         }
3638                         *fixed_portion = 24;
3639                         break;
3640
3641                 case SMB_QUERY_FS_SIZE_INFO:
3642                 case SMB_FS_SIZE_INFORMATION:
3643                 {
3644                         uint64_t dfree,dsize,bsize,block_size,sectors_per_unit;
3645                         data_len = 24;
3646                         df_ret = get_dfree_info(conn, &smb_fname, &bsize,
3647                                                 &dfree, &dsize);
3648                         if (df_ret == (uint64_t)-1) {
3649                                 return map_nt_error_from_unix(errno);
3650                         }
3651                         block_size = lp_block_size(snum);
3652                         if (bsize < block_size) {
3653                                 uint64_t factor = block_size/bsize;
3654                                 bsize = block_size;
3655                                 dsize /= factor;
3656                                 dfree /= factor;
3657                         }
3658                         if (bsize > block_size) {
3659                                 uint64_t factor = bsize/block_size;
3660                                 bsize = block_size;
3661                                 dsize *= factor;
3662                                 dfree *= factor;
3663                         }
3664                         sectors_per_unit = bsize/bytes_per_sector;
3665                         DEBUG(5,("smbd_do_qfsinfo : SMB_QUERY_FS_SIZE_INFO bsize=%u, cSectorUnit=%u, \
3666 cBytesSector=%u, cUnitTotal=%u, cUnitAvail=%d\n", (unsigned int)bsize, (unsigned int)sectors_per_unit,
3667                                 (unsigned int)bytes_per_sector, (unsigned int)dsize, (unsigned int)dfree));
3668                         SBIG_UINT(pdata,0,dsize);
3669                         SBIG_UINT(pdata,8,dfree);
3670                         SIVAL(pdata,16,sectors_per_unit);
3671                         SIVAL(pdata,20,bytes_per_sector);
3672                         *fixed_portion = 24;
3673                         break;
3674                 }
3675
3676                 case SMB_FS_FULL_SIZE_INFORMATION:
3677                 {
3678                         uint64_t dfree,dsize,bsize,block_size,sectors_per_unit;
3679                         data_len = 32;
3680                         df_ret = get_dfree_info(conn, &smb_fname, &bsize,
3681                                                 &dfree, &dsize);
3682                         if (df_ret == (uint64_t)-1) {
3683                                 return map_nt_error_from_unix(errno);
3684                         }
3685                         block_size = lp_block_size(snum);
3686                         if (bsize < block_size) {
3687                                 uint64_t factor = block_size/bsize;
3688                                 bsize = block_size;
3689                                 dsize /= factor;
3690                                 dfree /= factor;
3691                         }
3692                         if (bsize > block_size) {
3693                                 uint64_t factor = bsize/block_size;
3694                                 bsize = block_size;
3695                                 dsize *= factor;
3696                                 dfree *= factor;
3697                         }
3698                         sectors_per_unit = bsize/bytes_per_sector;
3699                         DEBUG(5,("smbd_do_qfsinfo : SMB_QUERY_FS_FULL_SIZE_INFO bsize=%u, cSectorUnit=%u, \
3700 cBytesSector=%u, cUnitTotal=%u, cUnitAvail=%d\n", (unsigned int)bsize, (unsigned int)sectors_per_unit,
3701                                 (unsigned int)bytes_per_sector, (unsigned int)dsize, (unsigned int)dfree));
3702                         SBIG_UINT(pdata,0,dsize); /* Total Allocation units. */
3703                         SBIG_UINT(pdata,8,dfree); /* Caller available allocation units. */
3704                         SBIG_UINT(pdata,16,dfree); /* Actual available allocation units. */
3705                         SIVAL(pdata,24,sectors_per_unit); /* Sectors per allocation unit. */
3706                         SIVAL(pdata,28,bytes_per_sector); /* Bytes per sector. */
3707                         *fixed_portion = 32;
3708                         break;
3709                 }
3710
3711                 case SMB_QUERY_FS_DEVICE_INFO:
3712                 case SMB_FS_DEVICE_INFORMATION:
3713                 {
3714                         uint32_t characteristics = FILE_DEVICE_IS_MOUNTED;
3715
3716                         if (!CAN_WRITE(conn)) {
3717                                 characteristics |= FILE_READ_ONLY_DEVICE;
3718                         }
3719                         data_len = 8;
3720                         SIVAL(pdata,0,FILE_DEVICE_DISK); /* dev type */
3721                         SIVAL(pdata,4,characteristics);
3722                         *fixed_portion = 8;
3723                         break;
3724                 }
3725
3726 #ifdef HAVE_SYS_QUOTAS
3727                 case SMB_FS_QUOTA_INFORMATION:
3728                 /*
3729                  * what we have to send --metze:
3730                  *
3731                  * Unknown1:            24 NULL bytes
3732                  * Soft Quota Treshold: 8 bytes seems like uint64_t or so
3733                  * Hard Quota Limit:    8 bytes seems like uint64_t or so
3734                  * Quota Flags:         2 byte :
3735                  * Unknown3:            6 NULL bytes
3736                  *
3737                  * 48 bytes total
3738                  *
3739                  * details for Quota Flags:
3740                  *
3741                  * 0x0020 Log Limit: log if the user exceeds his Hard Quota
3742                  * 0x0010 Log Warn:  log if the user exceeds his Soft Quota
3743                  * 0x0002 Deny Disk: deny disk access when the user exceeds his Hard Quota
3744                  * 0x0001 Enable Quotas: enable quota for this fs
3745                  *
3746                  */
3747                 {
3748                         /* we need to fake up a fsp here,
3749                          * because its not send in this call
3750                          */
3751                         files_struct fsp;
3752                         SMB_NTQUOTA_STRUCT quotas;
3753
3754                         ZERO_STRUCT(fsp);
3755                         ZERO_STRUCT(quotas);
3756
3757                         fsp.conn = conn;
3758                         fsp.fnum = FNUM_FIELD_INVALID;
3759
3760                         /* access check */
3761                         if (get_current_uid(conn) != 0) {
3762                                 DEBUG(0,("get_user_quota: access_denied "
3763                                          "service [%s] user [%s]\n",
3764                                          lp_servicename(talloc_tos(), SNUM(conn)),
3765                                          conn->session_info->unix_info->unix_name));
3766                                 return NT_STATUS_ACCESS_DENIED;
3767                         }
3768
3769                         status = vfs_get_ntquota(&fsp, SMB_USER_FS_QUOTA_TYPE,
3770                                                  NULL, &quotas);
3771                         if (!NT_STATUS_IS_OK(status)) {
3772                                 DEBUG(0,("vfs_get_ntquota() failed for service [%s]\n",lp_servicename(talloc_tos(), SNUM(conn))));
3773                                 return status;
3774                         }
3775
3776                         data_len = 48;
3777
3778                         DEBUG(10,("SMB_FS_QUOTA_INFORMATION: for service [%s]\n",
3779                                   lp_servicename(talloc_tos(), SNUM(conn))));
3780
3781                         /* Unknown1 24 NULL bytes*/
3782                         SBIG_UINT(pdata,0,(uint64_t)0);
3783                         SBIG_UINT(pdata,8,(uint64_t)0);
3784                         SBIG_UINT(pdata,16,(uint64_t)0);
3785
3786                         /* Default Soft Quota 8 bytes */
3787                         SBIG_UINT(pdata,24,quotas.softlim);
3788
3789                         /* Default Hard Quota 8 bytes */
3790                         SBIG_UINT(pdata,32,quotas.hardlim);
3791
3792                         /* Quota flag 2 bytes */
3793                         SSVAL(pdata,40,quotas.qflags);
3794
3795                         /* Unknown3 6 NULL bytes */
3796                         SSVAL(pdata,42,0);
3797                         SIVAL(pdata,44,0);
3798
3799                         break;
3800                 }
3801 #endif /* HAVE_SYS_QUOTAS */
3802                 case SMB_FS_OBJECTID_INFORMATION:
3803                 {
3804                         unsigned char objid[16];
3805                         struct smb_extended_info extended_info;
3806                         memcpy(pdata,create_volume_objectid(conn, objid),16);
3807                         samba_extended_info_version (&extended_info);
3808                         SIVAL(pdata,16,extended_info.samba_magic);
3809                         SIVAL(pdata,20,extended_info.samba_version);
3810                         SIVAL(pdata,24,extended_info.samba_subversion);
3811                         SBIG_UINT(pdata,28,extended_info.samba_gitcommitdate);
3812                         memcpy(pdata+36,extended_info.samba_version_string,28);
3813                         data_len = 64;
3814                         break;
3815                 }
3816
3817                 case SMB_FS_SECTOR_SIZE_INFORMATION:
3818                 {
3819                         data_len = 28;
3820                         /*
3821                          * These values match a physical Windows Server 2012
3822                          * share backed by NTFS atop spinning rust.
3823                          */
3824                         DEBUG(5, ("SMB_FS_SECTOR_SIZE_INFORMATION:"));
3825                         /* logical_bytes_per_sector */
3826                         SIVAL(pdata, 0, bytes_per_sector);
3827                         /* phys_bytes_per_sector_atomic */
3828                         SIVAL(pdata, 4, bytes_per_sector);
3829                         /* phys_bytes_per_sector_perf */
3830                         SIVAL(pdata, 8, bytes_per_sector);
3831                         /* fs_effective_phys_bytes_per_sector_atomic */
3832                         SIVAL(pdata, 12, bytes_per_sector);
3833                         /* flags */
3834                         SIVAL(pdata, 16, SSINFO_FLAGS_ALIGNED_DEVICE
3835                                 | SSINFO_FLAGS_PARTITION_ALIGNED_ON_DEVICE);
3836                         /* byte_off_sector_align */
3837                         SIVAL(pdata, 20, 0);
3838                         /* byte_off_partition_align */
3839                         SIVAL(pdata, 24, 0);
3840                         *fixed_portion = 28;
3841                         break;
3842                 }
3843
3844
3845                 /*
3846                  * Query the version and capabilities of the CIFS UNIX extensions
3847                  * in use.
3848                  */
3849
3850                 case SMB_QUERY_CIFS_UNIX_INFO:
3851                 {
3852                         bool large_write = lp_min_receive_file_size() &&
3853                                         !srv_is_signing_active(xconn);
3854                         bool large_read = !srv_is_signing_active(xconn);
3855                         int encrypt_caps = 0;
3856
3857                         if (!lp_unix_extensions()) {
3858                                 return NT_STATUS_INVALID_LEVEL;
3859                         }
3860
3861                         switch (conn->encrypt_level) {
3862                         case SMB_SIGNING_OFF:
3863                                 encrypt_caps = 0;
3864                                 break;
3865                         case SMB_SIGNING_DESIRED:
3866                         case SMB_SIGNING_IF_REQUIRED:
3867                         case SMB_SIGNING_DEFAULT:
3868                                 encrypt_caps = CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP;
3869                                 break;
3870                         case SMB_SIGNING_REQUIRED:
3871                                 encrypt_caps = CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP|
3872                                                 CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP;
3873                                 large_write = false;
3874                                 large_read = false;
3875                                 break;
3876                         }
3877
3878                         data_len = 12;
3879                         SSVAL(pdata,0,CIFS_UNIX_MAJOR_VERSION);
3880                         SSVAL(pdata,2,CIFS_UNIX_MINOR_VERSION);
3881
3882                         /* We have POSIX ACLs, pathname, encryption,
3883                          * large read/write, and locking capability. */
3884
3885                         SBIG_UINT(pdata,4,((uint64_t)(
3886                                         CIFS_UNIX_POSIX_ACLS_CAP|
3887                                         CIFS_UNIX_POSIX_PATHNAMES_CAP|
3888                                         CIFS_UNIX_FCNTL_LOCKS_CAP|
3889                                         CIFS_UNIX_EXTATTR_CAP|
3890                                         CIFS_UNIX_POSIX_PATH_OPERATIONS_CAP|
3891                                         encrypt_caps|
3892                                         (large_read ? CIFS_UNIX_LARGE_READ_CAP : 0) |
3893                                         (large_write ?
3894                                         CIFS_UNIX_LARGE_WRITE_CAP : 0))));
3895                         break;
3896                 }
3897
3898                 case SMB_QUERY_POSIX_FS_INFO:
3899                 {
3900                         int rc;
3901                         vfs_statvfs_struct svfs;
3902
3903                         if (!lp_unix_extensions()) {
3904                                 return NT_STATUS_INVALID_LEVEL;
3905                         }
3906
3907                         rc = SMB_VFS_STATVFS(conn, &smb_fname, &svfs);
3908
3909                         if (!rc) {
3910                                 data_len = 56;
3911                                 SIVAL(pdata,0,svfs.OptimalTransferSize);
3912                                 SIVAL(pdata,4,svfs.BlockSize);
3913                                 SBIG_UINT(pdata,8,svfs.TotalBlocks);
3914                                 SBIG_UINT(pdata,16,svfs.BlocksAvail);
3915                                 SBIG_UINT(pdata,24,svfs.UserBlocksAvail);
3916                                 SBIG_UINT(pdata,32,svfs.TotalFileNodes);
3917                                 SBIG_UINT(pdata,40,svfs.FreeFileNodes);
3918                                 SBIG_UINT(pdata,48,svfs.FsIdentifier);
3919                                 DEBUG(5,("smbd_do_qfsinfo : SMB_QUERY_POSIX_FS_INFO succsessful\n"));
3920 #ifdef EOPNOTSUPP
3921                         } else if (rc == EOPNOTSUPP) {
3922                                 return NT_STATUS_INVALID_LEVEL;
3923 #endif /* EOPNOTSUPP */
3924                         } else {
3925                                 DEBUG(0,("vfs_statvfs() failed for service [%s]\n",lp_servicename(talloc_tos(), SNUM(conn))));
3926                                 return NT_STATUS_DOS(ERRSRV, ERRerror);
3927                         }
3928                         break;
3929                 }
3930
3931                 case SMB_QUERY_POSIX_WHOAMI:
3932                 {
3933                         uint32_t flags = 0;
3934                         uint32_t sid_bytes;
3935                         int i;
3936
3937                         if (!lp_unix_extensions()) {
3938                                 return NT_STATUS_INVALID_LEVEL;
3939                         }
3940
3941                         if (max_data_bytes < 40) {
3942                                 return NT_STATUS_BUFFER_TOO_SMALL;
3943                         }
3944
3945                         if (security_session_user_level(conn->session_info, NULL) < SECURITY_USER) {
3946                                 flags |= SMB_WHOAMI_GUEST;
3947                         }
3948
3949                         /* NOTE: 8 bytes for UID/GID, irrespective of native
3950                          * platform size. This matches
3951                          * SMB_QUERY_FILE_UNIX_BASIC and friends.
3952                          */
3953                         data_len = 4 /* flags */
3954                             + 4 /* flag mask */
3955                             + 8 /* uid */
3956                             + 8 /* gid */
3957                             + 4 /* ngroups */
3958                             + 4 /* num_sids */
3959                             + 4 /* SID bytes */
3960                             + 4 /* pad/reserved */
3961                             + (conn->session_info->unix_token->ngroups * 8)
3962                                 /* groups list */
3963                             + (conn->session_info->security_token->num_sids *
3964                                     SID_MAX_SIZE)
3965                                 /* SID list */;
3966
3967                         SIVAL(pdata, 0, flags);
3968                         SIVAL(pdata, 4, SMB_WHOAMI_MASK);
3969                         SBIG_UINT(pdata, 8,
3970                                   (uint64_t)conn->session_info->unix_token->uid);
3971                         SBIG_UINT(pdata, 16,
3972                                   (uint64_t)conn->session_info->unix_token->gid);
3973
3974
3975                         if (data_len >= max_data_bytes) {
3976                                 /* Potential overflow, skip the GIDs and SIDs. */
3977
3978                                 SIVAL(pdata, 24, 0); /* num_groups */
3979                                 SIVAL(pdata, 28, 0); /* num_sids */
3980                                 SIVAL(pdata, 32, 0); /* num_sid_bytes */
3981                                 SIVAL(pdata, 36, 0); /* reserved */
3982
3983                                 data_len = 40;
3984                                 break;
3985                         }
3986
3987                         SIVAL(pdata, 24, conn->session_info->unix_token->ngroups);
3988                         SIVAL(pdata, 28, conn->session_info->security_token->num_sids);
3989
3990                         /* We walk the SID list twice, but this call is fairly
3991                          * infrequent, and I don't expect that it's performance
3992                          * sensitive -- jpeach
3993                          */
3994                         for (i = 0, sid_bytes = 0;
3995                              i < conn->session_info->security_token->num_sids; ++i) {
3996                                 sid_bytes += ndr_size_dom_sid(
3997                                         &conn->session_info->security_token->sids[i],
3998                                         0);
3999                         }
4000
4001                         /* SID list byte count */
4002                         SIVAL(pdata, 32, sid_bytes);
4003
4004                         /* 4 bytes pad/reserved - must be zero */
4005                         SIVAL(pdata, 36, 0);
4006                         data_len = 40;
4007
4008                         /* GID list */
4009                         for (i = 0; i < conn->session_info->unix_token->ngroups; ++i) {
4010                                 SBIG_UINT(pdata, data_len,
4011                                           (uint64_t)conn->session_info->unix_token->groups[i]);
4012                                 data_len += 8;
4013                         }
4014
4015                         /* SID list */
4016                         for (i = 0;
4017                             i < conn->session_info->security_token->num_sids; ++i) {
4018                                 int sid_len = ndr_size_dom_sid(
4019                                         &conn->session_info->security_token->sids[i],
4020                                         0);
4021
4022                                 sid_linearize((uint8_t *)(pdata + data_len),
4023                                               sid_len,
4024                                     &conn->session_info->security_token->sids[i]);
4025                                 data_len += sid_len;
4026                         }
4027
4028                         break;
4029                 }
4030
4031                 case SMB_MAC_QUERY_FS_INFO:
4032                         /*
4033                          * Thursby MAC extension... ONLY on NTFS filesystems
4034                          * once we do streams then we don't need this
4035                          */
4036                         if (strequal(lp_fstype(SNUM(conn)),"NTFS")) {
4037                                 data_len = 88;
4038                                 SIVAL(pdata,84,0x100); /* Don't support mac... */
4039                                 break;
4040                         }
4041                         /* drop through */
4042                 default:
4043                         return NT_STATUS_INVALID_LEVEL;
4044         }
4045
4046         *ret_data_len = data_len;
4047         return status;
4048 }
4049
4050 static NTSTATUS smb_set_fsquota(connection_struct *conn,
4051                         struct smb_request *req,
4052                         files_struct *fsp,
4053                         const DATA_BLOB *qdata)
4054 {
4055         NTSTATUS status;
4056         SMB_NTQUOTA_STRUCT quotas;
4057
4058         ZERO_STRUCT(quotas);
4059
4060         /* access check */
4061         if ((get_current_uid(conn) != 0) || !CAN_WRITE(conn)) {
4062                 DEBUG(3, ("set_fsquota: access_denied service [%s] user [%s]\n",
4063                           lp_servicename(talloc_tos(), SNUM(conn)),
4064                           conn->session_info->unix_info->unix_name));
4065                 return NT_STATUS_ACCESS_DENIED;
4066         }
4067
4068         if (!check_fsp_ntquota_handle(conn, req,
4069                                       fsp)) {
4070                 DEBUG(1, ("set_fsquota: no valid QUOTA HANDLE\n"));
4071                 return NT_STATUS_INVALID_HANDLE;
4072         }
4073
4074         /* note: normally there're 48 bytes,
4075          * but we didn't use the last 6 bytes for now
4076          * --metze
4077          */
4078         if (qdata->length < 42) {
4079                 DEBUG(0,("set_fsquota: requires total_data(%u) >= 42 bytes!\n",
4080                         (unsigned int)qdata->length));
4081                 return NT_STATUS_INVALID_PARAMETER;
4082         }
4083
4084         /* unknown_1 24 NULL bytes in pdata*/
4085
4086         /* the soft quotas 8 bytes (uint64_t)*/
4087         quotas.softlim = BVAL(qdata->data,24);
4088
4089         /* the hard quotas 8 bytes (uint64_t)*/
4090         quotas.hardlim = BVAL(qdata->data,32);
4091
4092         /* quota_flags 2 bytes **/
4093         quotas.qflags = SVAL(qdata->data,40);
4094
4095         /* unknown_2 6 NULL bytes follow*/
4096
4097         /* now set the quotas */
4098         if (vfs_set_ntquota(fsp, SMB_USER_FS_QUOTA_TYPE, NULL, &quotas)!=0) {
4099                 DEBUG(1, ("vfs_set_ntquota() failed for service [%s]\n",
4100                           lp_servicename(talloc_tos(), SNUM(conn))));
4101                 status =  map_nt_error_from_unix(errno);
4102         } else {
4103                 status = NT_STATUS_OK;
4104         }
4105         return status;
4106 }
4107
4108 NTSTATUS smbd_do_setfsinfo(connection_struct *conn,
4109                                 struct smb_request *req,
4110                                 TALLOC_CTX *mem_ctx,
4111                                 uint16_t info_level,
4112                                 files_struct *fsp,
4113                                 const DATA_BLOB *pdata)
4114 {
4115         switch (info_level) {
4116                 case SMB_FS_QUOTA_INFORMATION:
4117                 {
4118                         return smb_set_fsquota(conn,
4119                                                 req,
4120                                                 fsp,
4121                                                 pdata);
4122                 }
4123
4124                 default:
4125                         break;
4126         }
4127         return NT_STATUS_INVALID_LEVEL;
4128 }
4129
4130 /****************************************************************************
4131  Reply to a TRANS2_QFSINFO (query filesystem info).
4132 ****************************************************************************/
4133
4134 static void call_trans2qfsinfo(connection_struct *conn,
4135                                struct smb_request *req,
4136                                char **pparams, int total_params,
4137                                char **ppdata, int total_data,
4138                                unsigned int max_data_bytes)
4139 {
4140         char *params = *pparams;
4141         uint16_t info_level;
4142         int data_len = 0;
4143         size_t fixed_portion;
4144         NTSTATUS status;
4145
4146         if (total_params < 2) {
4147                 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
4148                 return;
4149         }
4150
4151         info_level = SVAL(params,0);
4152
4153         if (ENCRYPTION_REQUIRED(conn) && !req->encrypted) {
4154                 if (info_level != SMB_QUERY_CIFS_UNIX_INFO) {
4155                         DEBUG(0,("call_trans2qfsinfo: encryption required "
4156                                 "and info level 0x%x sent.\n",
4157                                 (unsigned int)info_level));
4158                         reply_nterror(req, NT_STATUS_ACCESS_DENIED);
4159                         return;
4160                 }
4161         }
4162
4163         DEBUG(3,("call_trans2qfsinfo: level = %d\n", info_level));
4164
4165         status = smbd_do_qfsinfo(req->xconn, conn, req,
4166                                  info_level,
4167                                  req->flags2,
4168                                  max_data_bytes,
4169                                  &fixed_portion,
4170                                  NULL,
4171                                  ppdata, &data_len);
4172         if (!NT_STATUS_IS_OK(status)) {
4173                 reply_nterror(req, status);
4174                 return;
4175         }
4176
4177         send_trans2_replies(conn, req, NT_STATUS_OK, params, 0, *ppdata, data_len,
4178                             max_data_bytes);
4179
4180         DEBUG( 4, ( "%s info_level = %d\n",
4181                     smb_fn_name(req->cmd), info_level) );
4182
4183         return;
4184 }
4185
4186 /****************************************************************************
4187  Reply to a TRANS2_SETFSINFO (set filesystem info).
4188 ****************************************************************************/
4189
4190 static void call_trans2setfsinfo(connection_struct *conn,
4191                                  struct smb_request *req,
4192                                  char **pparams, int total_params,
4193                                  char **ppdata, int total_data,
4194                                  unsigned int max_data_bytes)
4195 {
4196         struct smbXsrv_connection *xconn = req->xconn;
4197         char *pdata = *ppdata;
4198         char *params = *pparams;
4199         uint16_t info_level;
4200
4201         DEBUG(10,("call_trans2setfsinfo: for service [%s]\n",
4202                   lp_servicename(talloc_tos(), SNUM(conn))));
4203
4204         /*  */
4205         if (total_params < 4) {
4206                 DEBUG(0,("call_trans2setfsinfo: requires total_params(%d) >= 4 bytes!\n",
4207                         total_params));
4208                 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
4209                 return;
4210         }
4211
4212         info_level = SVAL(params,2);
4213
4214         if (IS_IPC(conn)) {
4215                 if (info_level != SMB_REQUEST_TRANSPORT_ENCRYPTION &&
4216                                 info_level != SMB_SET_CIFS_UNIX_INFO) {
4217                         DEBUG(0,("call_trans2setfsinfo: not an allowed "
4218                                 "info level (0x%x) on IPC$.\n",
4219                                 (unsigned int)info_level));
4220                         reply_nterror(req, NT_STATUS_ACCESS_DENIED);
4221                         return;
4222                 }
4223         }
4224
4225         if (ENCRYPTION_REQUIRED(conn) && !req->encrypted) {
4226                 if (info_level != SMB_REQUEST_TRANSPORT_ENCRYPTION) {
4227                         DEBUG(0,("call_trans2setfsinfo: encryption required "
4228                                 "and info level 0x%x sent.\n",
4229                                 (unsigned int)info_level));
4230                         reply_nterror(req, NT_STATUS_ACCESS_DENIED);
4231                         return;
4232                 }
4233         }
4234
4235         switch(info_level) {
4236                 case SMB_SET_CIFS_UNIX_INFO:
4237                         if (!lp_unix_extensions()) {
4238                                 DEBUG(2,("call_trans2setfsinfo: "
4239                                         "SMB_SET_CIFS_UNIX_INFO is invalid with "
4240                                         "unix extensions off\n"));
4241                                 reply_nterror(req,
4242                                               NT_STATUS_INVALID_LEVEL);
4243                                 return;
4244                         }
4245
4246                         /* There should be 12 bytes of capabilities set. */
4247                         if (total_data < 12) {
4248                                 reply_nterror(
4249                                         req,
4250                                         NT_STATUS_INVALID_PARAMETER);
4251                                 return;
4252                         }
4253                         xconn->smb1.unix_info.client_major = SVAL(pdata,0);
4254                         xconn->smb1.unix_info.client_minor = SVAL(pdata,2);
4255                         xconn->smb1.unix_info.client_cap_low = IVAL(pdata,4);
4256                         xconn->smb1.unix_info.client_cap_high = IVAL(pdata,8);
4257                         /* Just print these values for now. */
4258                         DEBUG(10, ("call_trans2setfsinfo: set unix_info info. "
4259                                    "major = %u, minor = %u cap_low = 0x%x, "
4260                                    "cap_high = 0x%xn",
4261                                    (unsigned int)xconn->
4262                                    smb1.unix_info.client_major,
4263                                    (unsigned int)xconn->
4264                                    smb1.unix_info.client_minor,
4265                                    (unsigned int)xconn->
4266                                    smb1.unix_info.client_cap_low,
4267                                    (unsigned int)xconn->
4268                                    smb1.unix_info.client_cap_high));
4269
4270                         /* Here is where we must switch to posix pathname processing... */
4271                         if (xconn->smb1.unix_info.client_cap_low & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
4272                                 lp_set_posix_pathnames();
4273                                 mangle_change_to_posix();
4274                         }
4275
4276                         if ((xconn->smb1.unix_info.client_cap_low & CIFS_UNIX_FCNTL_LOCKS_CAP) &&
4277                             !(xconn->smb1.unix_info.client_cap_low & CIFS_UNIX_POSIX_PATH_OPERATIONS_CAP)) {
4278                                 /* Client that knows how to do posix locks,
4279                                  * but not posix open/mkdir operations. Set a
4280                                  * default type for read/write checks. */
4281
4282                                 lp_set_posix_default_cifsx_readwrite_locktype(POSIX_LOCK);
4283
4284                         }
4285                         break;
4286
4287                 case SMB_REQUEST_TRANSPORT_ENCRYPTION:
4288                         {
4289                                 NTSTATUS status;
4290                                 size_t param_len = 0;
4291                                 size_t data_len = total_data;
4292
4293                                 if (!lp_unix_extensions()) {
4294                                         reply_nterror(
4295                                                 req,
4296                                                 NT_STATUS_INVALID_LEVEL);
4297                                         return;
4298                                 }
4299
4300                                 if (lp_smb_encrypt(SNUM(conn)) == SMB_SIGNING_OFF) {
4301                                         reply_nterror(
4302                                                 req,
4303                                                 NT_STATUS_NOT_SUPPORTED);
4304                                         return;
4305                                 }
4306
4307                                 if (xconn->smb1.echo_handler.trusted_fde) {
4308                                         DEBUG( 2,("call_trans2setfsinfo: "
4309                                                 "request transport encryption disabled"
4310                                                 "with 'fork echo handler = yes'\n"));
4311                                         reply_nterror(
4312                                                 req,
4313                                                 NT_STATUS_NOT_SUPPORTED);
4314                                         return;
4315                                 }
4316
4317                                 DEBUG( 4,("call_trans2setfsinfo: "
4318                                         "request transport encryption.\n"));
4319
4320                                 status = srv_request_encryption_setup(conn,
4321                                                                 (unsigned char **)ppdata,
4322                                                                 &data_len,
4323                                                                 (unsigned char **)pparams,
4324                                                                 &param_len);
4325
4326                                 if (!NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED) &&
4327                                                 !NT_STATUS_IS_OK(status)) {
4328                                         reply_nterror(req, status);
4329                                         return;
4330                                 }
4331
4332                                 send_trans2_replies(conn, req,
4333                                                 NT_STATUS_OK,
4334                                                 *pparams,
4335                                                 param_len,
4336                                                 *ppdata,
4337                                                 data_len,
4338                                                 max_data_bytes);
4339
4340                                 if (NT_STATUS_IS_OK(status)) {
4341                                         /* Server-side transport
4342                                          * encryption is now *on*. */
4343                                         status = srv_encryption_start(conn);
4344                                         if (!NT_STATUS_IS_OK(status)) {
4345                                                 char *reason = talloc_asprintf(talloc_tos(),
4346                                                                                "Failure in setting "
4347                                                                                "up encrypted transport: %s",
4348                                                                                nt_errstr(status));
4349                                                 exit_server_cleanly(reason);
4350                                         }
4351                                 }
4352                                 return;
4353                         }
4354
4355                 case SMB_FS_QUOTA_INFORMATION:
4356                         {
4357                                 NTSTATUS status;
4358                                 DATA_BLOB qdata = {
4359                                                 .data = (uint8_t *)pdata,
4360                                                 .length = total_data
4361                                 };
4362                                 files_struct *fsp = NULL;
4363                                 fsp = file_fsp(req, SVAL(params,0));
4364
4365                                 status = smb_set_fsquota(conn,
4366                                                         req,
4367                                                         fsp,
4368                                                         &qdata);
4369                                 if (!NT_STATUS_IS_OK(status)) {
4370                                         reply_nterror(req, status);
4371                                         return;
4372                                 }
4373                                 break;
4374                         }
4375                 default:
4376                         DEBUG(3,("call_trans2setfsinfo: unknown level (0x%X) not implemented yet.\n",
4377                                 info_level));
4378                         reply_nterror(req, NT_STATUS_INVALID_LEVEL);
4379                         return;
4380                         break;
4381         }
4382
4383         /*
4384          * sending this reply works fine,
4385          * but I'm not sure it's the same
4386          * like windows do...
4387          * --metze
4388          */
4389         reply_outbuf(req, 10, 0);
4390 }
4391
4392 #if defined(HAVE_POSIX_ACLS)
4393 /****************************************************************************
4394  Utility function to count the number of entries in a POSIX acl.
4395 ****************************************************************************/
4396
4397 static unsigned int count_acl_entries(connection_struct *conn, SMB_ACL_T posix_acl)
4398 {
4399         unsigned int ace_count = 0;
4400         int entry_id = SMB_ACL_FIRST_ENTRY;
4401         SMB_ACL_ENTRY_T entry;
4402
4403         while ( posix_acl && (sys_acl_get_entry(posix_acl, entry_id, &entry) == 1)) {
4404                 /* get_next... */
4405                 if (entry_id == SMB_ACL_FIRST_ENTRY) {
4406                         entry_id = SMB_ACL_NEXT_ENTRY;
4407                 }
4408                 ace_count++;
4409         }
4410         return ace_count;
4411 }
4412
4413 /****************************************************************************
4414  Utility function to marshall a POSIX acl into wire format.
4415 ****************************************************************************/
4416
4417 static bool marshall_posix_acl(connection_struct *conn, char *pdata, SMB_STRUCT_STAT *pst, SMB_ACL_T posix_acl)
4418 {
4419         int entry_id = SMB_ACL_FIRST_ENTRY;
4420         SMB_ACL_ENTRY_T entry;
4421
4422         while ( posix_acl && (sys_acl_get_entry(posix_acl, entry_id, &entry) == 1)) {
4423                 SMB_ACL_TAG_T tagtype;
4424                 SMB_ACL_PERMSET_T permset;
4425                 unsigned char perms = 0;
4426                 unsigned int own_grp;
4427
4428                 /* get_next... */
4429                 if (entry_id == SMB_ACL_FIRST_ENTRY) {
4430                         entry_id = SMB_ACL_NEXT_ENTRY;
4431                 }
4432
4433                 if (sys_acl_get_tag_type(entry, &tagtype) == -1) {
4434                         DEBUG(0,("marshall_posix_acl: SMB_VFS_SYS_ACL_GET_TAG_TYPE failed.\n"));
4435                         return False;
4436                 }
4437
4438                 if (sys_acl_get_permset(entry, &permset) == -1) {
4439                         DEBUG(0,("marshall_posix_acl: SMB_VFS_SYS_ACL_GET_PERMSET failed.\n"));
4440                         return False;
4441                 }
4442
4443                 perms |= (sys_acl_get_perm(permset, SMB_ACL_READ) ? SMB_POSIX_ACL_READ : 0);
4444                 perms |= (sys_acl_get_perm(permset, SMB_ACL_WRITE) ? SMB_POSIX_ACL_WRITE : 0);
4445                 perms |= (sys_acl_get_perm(permset, SMB_ACL_EXECUTE) ? SMB_POSIX_ACL_EXECUTE : 0);
4446
4447                 SCVAL(pdata,1,perms);
4448
4449                 switch (tagtype) {
4450                         case SMB_ACL_USER_OBJ:
4451                                 SCVAL(pdata,0,SMB_POSIX_ACL_USER_OBJ);
4452                                 own_grp = (unsigned int)pst->st_ex_uid;
4453                                 SIVAL(pdata,2,own_grp);
4454                                 SIVAL(pdata,6,0);
4455                                 break;
4456                         case SMB_ACL_USER:
4457                                 {
4458                                         uid_t *puid = (uid_t *)sys_acl_get_qualifier(entry);
4459                                         if (!puid) {
4460                                                 DEBUG(0,("marshall_posix_acl: SMB_VFS_SYS_ACL_GET_QUALIFIER failed.\n"));
4461                                                 return False;
4462                                         }
4463                                         own_grp = (unsigned int)*puid;
4464                                         SCVAL(pdata,0,SMB_POSIX_ACL_USER);
4465                                         SIVAL(pdata,2,own_grp);
4466                                         SIVAL(pdata,6,0);
4467                                         break;
4468                                 }
4469                         case SMB_ACL_GROUP_OBJ:
4470                                 SCVAL(pdata,0,SMB_POSIX_ACL_GROUP_OBJ);
4471                                 own_grp = (unsigned int)pst->st_ex_gid;
4472                                 SIVAL(pdata,2,own_grp);
4473                                 SIVAL(pdata,6,0);
4474                                 break;
4475                         case SMB_ACL_GROUP:
4476                                 {
4477                                         gid_t *pgid= (gid_t *)sys_acl_get_qualifier(entry);
4478                                         if (!pgid) {
4479                                                 DEBUG(0,("marshall_posix_acl: SMB_VFS_SYS_ACL_GET_QUALIFIER failed.\n"));
4480                                                 return False;
4481                                         }
4482                                         own_grp = (unsigned int)*pgid;
4483                                         SCVAL(pdata,0,SMB_POSIX_ACL_GROUP);
4484                                         SIVAL(pdata,2,own_grp);
4485                                         SIVAL(pdata,6,0);
4486                                         break;
4487                                 }
4488                         case SMB_ACL_MASK:
4489                                 SCVAL(pdata,0,SMB_POSIX_ACL_MASK);
4490                                 SIVAL(pdata,2,0xFFFFFFFF);
4491                                 SIVAL(pdata,6,0xFFFFFFFF);
4492                                 break;
4493                         case SMB_ACL_OTHER:
4494                                 SCVAL(pdata,0,SMB_POSIX_ACL_OTHER);
4495                                 SIVAL(pdata,2,0xFFFFFFFF);
4496                                 SIVAL(pdata,6,0xFFFFFFFF);
4497                                 break;
4498                         default:
4499                                 DEBUG(0,("marshall_posix_acl: unknown tagtype.\n"));
4500                                 return False;
4501                 }
4502                 pdata += SMB_POSIX_ACL_ENTRY_SIZE;
4503         }
4504
4505         return True;
4506 }
4507 #endif
4508
4509 /****************************************************************************
4510  Store the FILE_UNIX_BASIC info.
4511 ****************************************************************************/
4512
4513 static char *store_file_unix_basic(connection_struct *conn,
4514                                 char *pdata,
4515                                 files_struct *fsp,
4516                                 const SMB_STRUCT_STAT *psbuf)
4517 {
4518         uint64_t file_index = get_FileIndex(conn, psbuf);
4519         dev_t devno;
4520
4521         DEBUG(10,("store_file_unix_basic: SMB_QUERY_FILE_UNIX_BASIC\n"));
4522         DEBUG(4,("store_file_unix_basic: st_mode=%o\n",(int)psbuf->st_ex_mode));
4523
4524         SOFF_T(pdata,0,get_file_size_stat(psbuf));             /* File size 64 Bit */
4525         pdata += 8;
4526
4527         SOFF_T(pdata,0,SMB_VFS_GET_ALLOC_SIZE(conn,fsp,psbuf)); /* Number of bytes used on disk - 64 Bit */
4528         pdata += 8;
4529
4530         put_long_date_timespec(TIMESTAMP_SET_NT_OR_BETTER, pdata, psbuf->st_ex_ctime);       /* Change Time 64 Bit */
4531         put_long_date_timespec(TIMESTAMP_SET_NT_OR_BETTER ,pdata+8, psbuf->st_ex_atime);     /* Last access time 64 Bit */
4532         put_long_date_timespec(TIMESTAMP_SET_NT_OR_BETTER, pdata+16, psbuf->st_ex_mtime);    /* Last modification time 64 Bit */
4533         pdata += 24;
4534
4535         SIVAL(pdata,0,psbuf->st_ex_uid);               /* user id for the owner */
4536         SIVAL(pdata,4,0);
4537         pdata += 8;
4538
4539         SIVAL(pdata,0,psbuf->st_ex_gid);               /* group id of owner */
4540         SIVAL(pdata,4,0);
4541         pdata += 8;
4542
4543         SIVAL(pdata,0,unix_filetype(psbuf->st_ex_mode));
4544         pdata += 4;
4545
4546         if (S_ISBLK(psbuf->st_ex_mode) || S_ISCHR(psbuf->st_ex_mode)) {
4547                 devno = psbuf->st_ex_rdev;
4548         } else {
4549                 devno = psbuf->st_ex_dev;
4550         }
4551
4552         SIVAL(pdata,0,unix_dev_major(devno));   /* Major device number if type is device */
4553         SIVAL(pdata,4,0);
4554         pdata += 8;
4555
4556         SIVAL(pdata,0,unix_dev_minor(devno));   /* Minor device number if type is device */
4557         SIVAL(pdata,4,0);
4558         pdata += 8;
4559
4560         SINO_T_VAL(pdata,0,(SMB_INO_T)file_index);   /* inode number */
4561         pdata += 8;
4562
4563         SIVAL(pdata,0, unix_perms_to_wire(psbuf->st_ex_mode));     /* Standard UNIX file permissions */
4564         SIVAL(pdata,4,0);
4565         pdata += 8;
4566
4567         SIVAL(pdata,0,psbuf->st_ex_nlink);             /* number of hard links */
4568         SIVAL(pdata,4,0);
4569         pdata += 8;
4570
4571         return pdata;
4572 }
4573
4574 /* Forward and reverse mappings from the UNIX_INFO2 file flags field and
4575  * the chflags(2) (or equivalent) flags.
4576  *
4577  * XXX: this really should be behind the VFS interface. To do this, we would
4578  * need to alter SMB_STRUCT_STAT so that it included a flags and a mask field.
4579  * Each VFS module could then implement its own mapping as appropriate for the
4580  * platform. We would then pass the SMB flags into SMB_VFS_CHFLAGS.
4581  */
4582 static const struct {unsigned stat_fflag; unsigned smb_fflag;}
4583         info2_flags_map[] =
4584 {
4585 #ifdef UF_NODUMP
4586     { UF_NODUMP, EXT_DO_NOT_BACKUP },
4587 #endif
4588
4589 #ifdef UF_IMMUTABLE
4590     { UF_IMMUTABLE, EXT_IMMUTABLE },
4591 #endif
4592
4593 #ifdef UF_APPEND
4594     { UF_APPEND, EXT_OPEN_APPEND_ONLY },
4595 #endif
4596
4597 #ifdef UF_HIDDEN
4598     { UF_HIDDEN, EXT_HIDDEN },
4599 #endif
4600
4601     /* Do not remove. We need to guarantee that this array has at least one
4602      * entry to build on HP-UX.
4603      */
4604     { 0, 0 }
4605
4606 };
4607
4608 static void map_info2_flags_from_sbuf(const SMB_STRUCT_STAT *psbuf,
4609                                 uint32_t *smb_fflags, uint32_t *smb_fmask)
4610 {
4611         int i;
4612
4613         for (i = 0; i < ARRAY_SIZE(info2_flags_map); ++i) {
4614             *smb_fmask |= info2_flags_map[i].smb_fflag;
4615             if (psbuf->st_ex_flags & info2_flags_map[i].stat_fflag) {
4616                     *smb_fflags |= info2_flags_map[i].smb_fflag;
4617             }
4618         }
4619 }
4620
4621 static bool map_info2_flags_to_sbuf(const SMB_STRUCT_STAT *psbuf,
4622                                 const uint32_t smb_fflags,
4623                                 const uint32_t smb_fmask,
4624                                 int *stat_fflags)
4625 {
4626         uint32_t max_fmask = 0;
4627         int i;
4628
4629         *stat_fflags = psbuf->st_ex_flags;
4630
4631         /* For each flags requested in smb_fmask, check the state of the
4632          * corresponding flag in smb_fflags and set or clear the matching
4633          * stat flag.
4634          */
4635
4636         for (i = 0; i < ARRAY_SIZE(info2_flags_map); ++i) {
4637             max_fmask |= info2_flags_map[i].smb_fflag;
4638             if (smb_fmask & info2_flags_map[i].smb_fflag) {
4639                     if (smb_fflags & info2_flags_map[i].smb_fflag) {
4640                             *stat_fflags |= info2_flags_map[i].stat_fflag;
4641                     } else {
4642                             *stat_fflags &= ~info2_flags_map[i].stat_fflag;
4643                     }
4644             }
4645         }
4646
4647         /* If smb_fmask is asking to set any bits that are not supported by
4648          * our flag mappings, we should fail.
4649          */
4650         if ((smb_fmask & max_fmask) != smb_fmask) {
4651                 return False;
4652         }
4653
4654         return True;
4655 }
4656
4657
4658 /* Just like SMB_QUERY_FILE_UNIX_BASIC, but with the addition
4659  * of file flags and birth (create) time.
4660  */
4661 static char *store_file_unix_basic_info2(connection_struct *conn,
4662                                 char *pdata,
4663                                 files_struct *fsp,
4664                                 const SMB_STRUCT_STAT *psbuf)
4665 {
4666         uint32_t file_flags = 0;
4667         uint32_t flags_mask = 0;
4668
4669         pdata = store_file_unix_basic(conn, pdata, fsp, psbuf);
4670
4671         /* Create (birth) time 64 bit */
4672         put_long_date_timespec(TIMESTAMP_SET_NT_OR_BETTER,pdata, psbuf->st_ex_btime);
4673         pdata += 8;
4674
4675         map_info2_flags_from_sbuf(psbuf, &file_flags, &flags_mask);
4676         SIVAL(pdata, 0, file_flags); /* flags */
4677         SIVAL(pdata, 4, flags_mask); /* mask */
4678         pdata += 8;
4679
4680         return pdata;
4681 }
4682
4683 static NTSTATUS marshall_stream_info(unsigned int num_streams,
4684                                      const struct stream_struct *streams,
4685                                      char *data,
4686                                      unsigned int max_data_bytes,
4687                                      unsigned int *data_size)
4688 {
4689         unsigned int i;
4690         unsigned int ofs = 0;
4691
4692         if (max_data_bytes < 32) {
4693                 return NT_STATUS_INFO_LENGTH_MISMATCH;
4694         }
4695
4696         for (i = 0; i < num_streams; i++) {
4697                 unsigned int next_offset;
4698                 size_t namelen;
4699                 smb_ucs2_t *namebuf;
4700
4701                 if (!push_ucs2_talloc(talloc_tos(), &namebuf,
4702                                       streams[i].name, &namelen) ||
4703                     namelen <= 2)
4704                 {
4705                         return NT_STATUS_INVALID_PARAMETER;
4706                 }
4707
4708                 /*
4709                  * name_buf is now null-terminated, we need to marshall as not
4710                  * terminated
4711                  */
4712
4713                 namelen -= 2;
4714
4715                 /*
4716                  * We cannot overflow ...
4717                  */
4718                 if ((ofs + 24 + namelen) > max_data_bytes) {
4719                         DEBUG(10, ("refusing to overflow reply at stream %u\n",
4720                                 i));
4721                         TALLOC_FREE(namebuf);
4722                         return STATUS_BUFFER_OVERFLOW;
4723                 }
4724
4725                 SIVAL(data, ofs+4, namelen);
4726                 SOFF_T(data, ofs+8, streams[i].size);
4727                 SOFF_T(data, ofs+16, streams[i].alloc_size);
4728                 memcpy(data+ofs+24, namebuf, namelen);
4729                 TALLOC_FREE(namebuf);
4730
4731                 next_offset = ofs + 24 + namelen;
4732
4733                 if (i == num_streams-1) {
4734                         SIVAL(data, ofs, 0);
4735                 }
4736                 else {
4737                         unsigned int align = ndr_align_size(next_offset, 8);
4738
4739                         if ((next_offset + align) > max_data_bytes) {
4740                                 DEBUG(10, ("refusing to overflow align "
4741                                         "reply at stream %u\n",
4742                                         i));
4743                                 TALLOC_FREE(namebuf);
4744                                 return STATUS_BUFFER_OVERFLOW;
4745                         }
4746
4747                         memset(data+next_offset, 0, align);
4748                         next_offset += align;
4749
4750                         SIVAL(data, ofs, next_offset - ofs);
4751                         ofs = next_offset;
4752                 }
4753
4754                 ofs = next_offset;
4755         }
4756
4757         DEBUG(10, ("max_data: %u, data_size: %u\n", max_data_bytes, ofs));
4758
4759         *data_size = ofs;
4760
4761         return NT_STATUS_OK;
4762 }
4763
4764 /****************************************************************************
4765  Reply to a TRANSACT2_QFILEINFO on a PIPE !
4766 ****************************************************************************/
4767
4768 static void call_trans2qpipeinfo(connection_struct *conn,
4769                                  struct smb_request *req,
4770                                  unsigned int tran_call,
4771                                  char **pparams, int total_params,
4772                                  char **ppdata, int total_data,
4773                                  unsigned int max_data_bytes)
4774 {
4775         char *params = *pparams;
4776         char *pdata = *ppdata;
4777         unsigned int data_size = 0;
4778         unsigned int param_size = 2;
4779         uint16_t info_level;
4780         files_struct *fsp;
4781
4782         if (!params) {
4783                 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
4784                 return;
4785         }
4786
4787         if (total_params < 4) {
4788                 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
4789                 return;
4790         }
4791
4792         fsp = file_fsp(req, SVAL(params,0));
4793         if (!fsp_is_np(fsp)) {
4794                 reply_nterror(req, NT_STATUS_INVALID_HANDLE);
4795                 return;
4796         }
4797
4798         info_level = SVAL(params,2);
4799
4800         *pparams = (char *)SMB_REALLOC(*pparams,2);
4801         if (*pparams == NULL) {
4802                 reply_nterror(req, NT_STATUS_NO_MEMORY);
4803                 return;
4804         }
4805         params = *pparams;
4806         SSVAL(params,0,0);
4807         if (max_data_bytes + DIR_ENTRY_SAFETY_MARGIN < max_data_bytes) {
4808                 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
4809                 return;
4810         }
4811         data_size = max_data_bytes + DIR_ENTRY_SAFETY_MARGIN;
4812         *ppdata = (char *)SMB_REALLOC(*ppdata, data_size);
4813         if (*ppdata == NULL ) {
4814                 reply_nterror(req, NT_STATUS_NO_MEMORY);
4815                 return;
4816         }
4817         pdata = *ppdata;
4818
4819         switch (info_level) {
4820                 case SMB_FILE_STANDARD_INFORMATION:
4821                         memset(pdata,0,24);
4822                         SOFF_T(pdata,0,4096LL);
4823                         SIVAL(pdata,16,1);
4824                         SIVAL(pdata,20,1);
4825                         data_size = 24;
4826                         break;
4827
4828                 default:
4829                         reply_nterror(req, NT_STATUS_INVALID_LEVEL);
4830                         return;
4831         }
4832
4833         send_trans2_replies(conn, req, NT_STATUS_OK, params, param_size, *ppdata, data_size,
4834                             max_data_bytes);
4835
4836         return;
4837 }
4838
4839 NTSTATUS smbd_do_qfilepathinfo(connection_struct *conn,
4840                                TALLOC_CTX *mem_ctx,
4841                                uint16_t info_level,
4842                                files_struct *fsp,
4843                                struct smb_filename *smb_fname,
4844                                bool delete_pending,
4845                                struct timespec write_time_ts,
4846                                struct ea_list *ea_list,
4847                                int lock_data_count,
4848                                char *lock_data,
4849                                uint16_t flags2,
4850                                unsigned int max_data_bytes,
4851                                size_t *fixed_portion,
4852                                char **ppdata,
4853                                unsigned int *pdata_size)
4854 {
4855         char *pdata = *ppdata;
4856         char *dstart, *dend;
4857         unsigned int data_size;
4858         struct timespec create_time_ts, mtime_ts, atime_ts, ctime_ts;
4859         time_t create_time, mtime, atime, c_time;
4860         SMB_STRUCT_STAT *psbuf = &smb_fname->st;
4861         char *p;
4862         char *base_name;
4863         char *dos_fname;
4864         int mode;
4865         int nlink;
4866         NTSTATUS status;
4867         uint64_t file_size = 0;
4868         uint64_t pos = 0;
4869         uint64_t allocation_size = 0;
4870         uint64_t file_index = 0;
4871         uint32_t access_mask = 0;
4872         size_t len = 0;
4873
4874         if (INFO_LEVEL_IS_UNIX(info_level) && !lp_unix_extensions()) {
4875                 return NT_STATUS_INVALID_LEVEL;
4876         }
4877
4878         DEBUG(5,("smbd_do_qfilepathinfo: %s (%s) level=%d max_data=%u\n",
4879                  smb_fname_str_dbg(smb_fname),
4880                  fsp_fnum_dbg(fsp),
4881                  info_level, max_data_bytes));
4882
4883         mode = dos_mode(conn, smb_fname);
4884         nlink = psbuf->st_ex_nlink;
4885
4886         if (nlink && (mode&FILE_ATTRIBUTE_DIRECTORY)) {
4887                 nlink = 1;
4888         }
4889
4890         if ((nlink > 0) && delete_pending) {
4891                 nlink -= 1;
4892         }
4893
4894         if (max_data_bytes + DIR_ENTRY_SAFETY_MARGIN < max_data_bytes) {
4895                 return NT_STATUS_INVALID_PARAMETER;
4896         }
4897
4898         data_size = max_data_bytes + DIR_ENTRY_SAFETY_MARGIN;
4899         *ppdata = (char *)SMB_REALLOC(*ppdata, data_size);
4900         if (*ppdata == NULL) {
4901                 return NT_STATUS_NO_MEMORY;
4902         }
4903         pdata = *ppdata;
4904         dstart = pdata;
4905         dend = dstart + data_size - 1;
4906
4907         if (!null_timespec(write_time_ts) && !INFO_LEVEL_IS_UNIX(info_level)) {
4908                 update_stat_ex_mtime(psbuf, write_time_ts);
4909         }
4910
4911         create_time_ts = get_create_timespec(conn, fsp, smb_fname);
4912         mtime_ts = psbuf->st_ex_mtime;
4913         atime_ts = psbuf->st_ex_atime;
4914         ctime_ts = get_change_timespec(conn, fsp, smb_fname);
4915
4916         if (lp_dos_filetime_resolution(SNUM(conn))) {
4917                 dos_filetime_timespec(&create_time_ts);
4918                 dos_filetime_timespec(&mtime_ts);
4919                 dos_filetime_timespec(&atime_ts);
4920                 dos_filetime_timespec(&ctime_ts);
4921         }
4922
4923         create_time = convert_timespec_to_time_t(create_time_ts);
4924         mtime = convert_timespec_to_time_t(mtime_ts);
4925         atime = convert_timespec_to_time_t(atime_ts);
4926         c_time = convert_timespec_to_time_t(ctime_ts);
4927
4928         p = strrchr_m(smb_fname->base_name,'/');
4929         if (!p)
4930                 base_name = smb_fname->base_name;
4931         else
4932                 base_name = p+1;
4933
4934         /* NT expects the name to be in an exact form of the *full*
4935            filename. See the trans2 torture test */
4936         if (ISDOT(base_name)) {
4937                 dos_fname = talloc_strdup(mem_ctx, "\\");
4938                 if (!dos_fname) {
4939                         return NT_STATUS_NO_MEMORY;
4940                 }
4941         } else {
4942                 dos_fname = talloc_asprintf(mem_ctx,
4943                                 "\\%s",
4944                                 smb_fname->base_name);
4945                 if (!dos_fname) {
4946                         return NT_STATUS_NO_MEMORY;
4947                 }
4948                 if (is_ntfs_stream_smb_fname(smb_fname)) {
4949                         dos_fname = talloc_asprintf(dos_fname, "%s",
4950                                                     smb_fname->stream_name);
4951                         if (!dos_fname) {
4952                                 return NT_STATUS_NO_MEMORY;
4953                         }
4954                 }
4955
4956                 string_replace(dos_fname, '/', '\\');
4957         }
4958
4959         allocation_size = SMB_VFS_GET_ALLOC_SIZE(conn, fsp, psbuf);
4960
4961         if (!fsp) {
4962                 /* Do we have this path open ? */
4963                 files_struct *fsp1;
4964                 struct file_id fileid = vfs_file_id_from_sbuf(conn, psbuf);
4965                 fsp1 = file_find_di_first(conn->sconn, fileid);
4966                 if (fsp1 && fsp1->initial_allocation_size) {
4967                         allocation_size = SMB_VFS_GET_ALLOC_SIZE(conn, fsp1, psbuf);
4968                 }
4969         }
4970
4971         if (!(mode & FILE_ATTRIBUTE_DIRECTORY)) {
4972                 file_size = get_file_size_stat(psbuf);
4973         }
4974
4975         if (fsp) {
4976                 pos = fsp->fh->position_information;
4977         }
4978
4979         if (fsp) {
4980                 access_mask = fsp->access_mask;
4981         } else {
4982                 /* GENERIC_EXECUTE mapping from Windows */
4983                 access_mask = 0x12019F;
4984         }
4985
4986         /* This should be an index number - looks like
4987            dev/ino to me :-)
4988
4989            I think this causes us to fail the IFSKIT
4990            BasicFileInformationTest. -tpot */
4991         file_index = get_FileIndex(conn, psbuf);
4992
4993         *fixed_portion = 0;
4994
4995         switch (info_level) {
4996                 case SMB_INFO_STANDARD:
4997                         DEBUG(10,("smbd_do_qfilepathinfo: SMB_INFO_STANDARD\n"));
4998                         data_size = 22;
4999                         srv_put_dos_date2(pdata,l1_fdateCreation,create_time);
5000                         srv_put_dos_date2(pdata,l1_fdateLastAccess,atime);
5001                         srv_put_dos_date2(pdata,l1_fdateLastWrite,mtime); /* write time */
5002                         SIVAL(pdata,l1_cbFile,(uint32_t)file_size);
5003                         SIVAL(pdata,l1_cbFileAlloc,(uint32_t)allocation_size);
5004                         SSVAL(pdata,l1_attrFile,mode);
5005                         break;
5006
5007                 case SMB_INFO_QUERY_EA_SIZE:
5008                 {
5009                         unsigned int ea_size =
5010                             estimate_ea_size(conn, fsp,
5011                                              smb_fname);
5012                         DEBUG(10,("smbd_do_qfilepathinfo: SMB_INFO_QUERY_EA_SIZE\n"));
5013                         data_size = 26;
5014                         srv_put_dos_date2(pdata,0,create_time);
5015                         srv_put_dos_date2(pdata,4,atime);
5016                         srv_put_dos_date2(pdata,8,mtime); /* write time */
5017                         SIVAL(pdata,12,(uint32_t)file_size);
5018                         SIVAL(pdata,16,(uint32_t)allocation_size);
5019                         SSVAL(pdata,20,mode);
5020                         SIVAL(pdata,22,ea_size);
5021                         break;
5022                 }
5023
5024                 case SMB_INFO_IS_NAME_VALID:
5025                         DEBUG(10,("smbd_do_qfilepathinfo: SMB_INFO_IS_NAME_VALID\n"));
5026                         if (fsp) {
5027                                 /* os/2 needs this ? really ?*/
5028                                 return NT_STATUS_DOS(ERRDOS, ERRbadfunc);
5029                         }
5030                         /* This is only reached for qpathinfo */
5031                         data_size = 0;
5032                         break;
5033
5034                 case SMB_INFO_QUERY_EAS_FROM_LIST:
5035                 {
5036                         size_t total_ea_len = 0;
5037                         struct ea_list *ea_file_list = NULL;
5038                         DEBUG(10,("smbd_do_qfilepathinfo: SMB_INFO_QUERY_EAS_FROM_LIST\n"));
5039
5040                         status =
5041                             get_ea_list_from_file(mem_ctx, conn, fsp,
5042                                                   smb_fname,
5043                                                   &total_ea_len, &ea_file_list);
5044                         if (!NT_STATUS_IS_OK(status)) {
5045                                 return status;
5046                         }
5047
5048                         ea_list = ea_list_union(ea_list, ea_file_list, &total_ea_len);
5049
5050                         if (!ea_list || (total_ea_len > data_size)) {
5051                                 data_size = 4;
5052                                 SIVAL(pdata,0,4);   /* EA List Length must be set to 4 if no EA's. */
5053                                 break;
5054                         }
5055
5056                         data_size = fill_ea_buffer(mem_ctx, pdata, data_size, conn, ea_list);
5057                         break;
5058                 }
5059
5060                 case SMB_INFO_QUERY_ALL_EAS:
5061                 {
5062                         /* We have data_size bytes to put EA's into. */
5063                         size_t total_ea_len = 0;
5064                         DEBUG(10,("smbd_do_qfilepathinfo: SMB_INFO_QUERY_ALL_EAS\n"));
5065
5066                         status = get_ea_list_from_file(mem_ctx, conn, fsp,
5067                                                         smb_fname,
5068                                                         &total_ea_len, &ea_list);
5069                         if (!NT_STATUS_IS_OK(status)) {
5070                                 return status;
5071                         }
5072
5073                         if (!ea_list || (total_ea_len > data_size)) {
5074                                 data_size = 4;
5075                                 SIVAL(pdata,0,4);   /* EA List Length must be set to 4 if no EA's. */
5076                                 break;
5077                         }
5078
5079                         data_size = fill_ea_buffer(mem_ctx, pdata, data_size, conn, ea_list);
5080                         break;
5081                 }
5082
5083                 case 0xFF0F:/*SMB2_INFO_QUERY_ALL_EAS*/
5084                 {
5085                         /* This is FileFullEaInformation - 0xF which maps to
5086                          * 1015 (decimal) in smbd_do_setfilepathinfo. */
5087
5088                         /* We have data_size bytes to put EA's into. */
5089                         size_t total_ea_len = 0;
5090                         struct ea_list *ea_file_list = NULL;
5091
5092                         DEBUG(10,("smbd_do_qfilepathinfo: SMB2_INFO_QUERY_ALL_EAS\n"));
5093
5094                         /*TODO: add filtering and index handling */
5095
5096                         status  =
5097                                 get_ea_list_from_file(mem_ctx, conn, fsp,
5098                                                   smb_fname,
5099                                                   &total_ea_len, &ea_file_list);
5100                         if (!NT_STATUS_IS_OK(status)) {
5101                                 return status;
5102                         }
5103                         if (!ea_file_list) {
5104                                 return NT_STATUS_NO_EAS_ON_FILE;
5105                         }
5106
5107                         status = fill_ea_chained_buffer(mem_ctx,
5108                                                         pdata,
5109                                                         data_size,
5110                                                         &data_size,
5111                                                         conn, ea_file_list);
5112                         if (!NT_STATUS_IS_OK(status)) {
5113                                 return status;
5114                         }
5115                         break;
5116                 }
5117
5118                 case SMB_FILE_BASIC_INFORMATION:
5119                 case SMB_QUERY_FILE_BASIC_INFO:
5120
5121                         if (info_level == SMB_QUERY_FILE_BASIC_INFO) {
5122                                 DEBUG(10,("smbd_do_qfilepathinfo: SMB_QUERY_FILE_BASIC_INFO\n"));
5123                                 data_size = 36; /* w95 returns 40 bytes not 36 - why ?. */
5124                         } else {
5125                                 DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_BASIC_INFORMATION\n"));
5126                                 data_size = 40;
5127                                 SIVAL(pdata,36,0);
5128                         }
5129                         put_long_date_timespec(conn->ts_res,pdata,create_time_ts);
5130                         put_long_date_timespec(conn->ts_res,pdata+8,atime_ts);
5131                         put_long_date_timespec(conn->ts_res,pdata+16,mtime_ts); /* write time */
5132                         put_long_date_timespec(conn->ts_res,pdata+24,ctime_ts); /* change time */
5133                         SIVAL(pdata,32,mode);
5134
5135                         DEBUG(5,("SMB_QFBI - "));
5136                         DEBUG(5,("create: %s ", ctime(&create_time)));
5137                         DEBUG(5,("access: %s ", ctime(&atime)));
5138                         DEBUG(5,("write: %s ", ctime(&mtime)));
5139                         DEBUG(5,("change: %s ", ctime(&c_time)));
5140                         DEBUG(5,("mode: %x\n", mode));
5141                         *fixed_portion = data_size;
5142                         break;
5143
5144                 case SMB_FILE_STANDARD_INFORMATION:
5145                 case SMB_QUERY_FILE_STANDARD_INFO:
5146
5147                         DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_STANDARD_INFORMATION\n"));
5148                         data_size = 24;
5149                         SOFF_T(pdata,0,allocation_size);
5150                         SOFF_T(pdata,8,file_size);
5151                         SIVAL(pdata,16,nlink);
5152                         SCVAL(pdata,20,delete_pending?1:0);
5153                         SCVAL(pdata,21,(mode&FILE_ATTRIBUTE_DIRECTORY)?1:0);
5154                         SSVAL(pdata,22,0); /* Padding. */
5155                         *fixed_portion = 24;
5156                         break;
5157
5158                 case SMB_FILE_EA_INFORMATION:
5159                 case SMB_QUERY_FILE_EA_INFO:
5160                 {
5161                         unsigned int ea_size =
5162                             estimate_ea_size(conn, fsp, smb_fname);
5163                         DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_EA_INFORMATION\n"));
5164                         data_size = 4;
5165                         *fixed_portion = 4;
5166                         SIVAL(pdata,0,ea_size);
5167                         break;
5168                 }
5169
5170                 /* Get the 8.3 name - used if NT SMB was negotiated. */
5171                 case SMB_QUERY_FILE_ALT_NAME_INFO:
5172                 case SMB_FILE_ALTERNATE_NAME_INFORMATION:
5173                 {
5174                         char mangled_name[13];
5175                         DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_ALTERNATE_NAME_INFORMATION\n"));
5176                         if (!name_to_8_3(base_name,mangled_name,
5177                                                 True,conn->params)) {
5178                                 return NT_STATUS_NO_MEMORY;
5179                         }
5180                         status = srvstr_push(dstart, flags2,
5181                                           pdata+4, mangled_name,
5182                                           PTR_DIFF(dend, pdata+4),
5183                                           STR_UNICODE, &len);
5184                         if (!NT_STATUS_IS_OK(status)) {
5185                                 return status;
5186                         }
5187                         data_size = 4 + len;
5188                         SIVAL(pdata,0,len);
5189                         *fixed_portion = 8;
5190                         break;
5191                 }
5192
5193                 case SMB_QUERY_FILE_NAME_INFO:
5194                 {
5195                         /*
5196                           this must be *exactly* right for ACLs on mapped drives to work
5197                          */
5198                         status = srvstr_push(dstart, flags2,
5199                                           pdata+4, dos_fname,
5200                                           PTR_DIFF(dend, pdata+4),
5201                                           STR_UNICODE, &len);
5202                         if (!NT_STATUS_IS_OK(status)) {
5203                                 return status;
5204                         }
5205                         DEBUG(10,("smbd_do_qfilepathinfo: SMB_QUERY_FILE_NAME_INFO\n"));
5206                         data_size = 4 + len;
5207                         SIVAL(pdata,0,len);
5208                         break;
5209                 }
5210
5211                 case SMB_FILE_ALLOCATION_INFORMATION:
5212                 case SMB_QUERY_FILE_ALLOCATION_INFO:
5213                         DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_ALLOCATION_INFORMATION\n"));
5214                         data_size = 8;
5215                         SOFF_T(pdata,0,allocation_size);
5216                         break;
5217
5218                 case SMB_FILE_END_OF_FILE_INFORMATION:
5219                 case SMB_QUERY_FILE_END_OF_FILEINFO:
5220                         DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_END_OF_FILE_INFORMATION\n"));
5221                         data_size = 8;
5222                         SOFF_T(pdata,0,file_size);
5223                         break;
5224
5225                 case SMB_QUERY_FILE_ALL_INFO:
5226                 case SMB_FILE_ALL_INFORMATION:
5227                 {
5228                         unsigned int ea_size =
5229                             estimate_ea_size(conn, fsp, smb_fname);
5230                         DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_ALL_INFORMATION\n"));
5231                         put_long_date_timespec(conn->ts_res,pdata,create_time_ts);
5232                         put_long_date_timespec(conn->ts_res,pdata+8,atime_ts);
5233                         put_long_date_timespec(conn->ts_res,pdata+16,mtime_ts); /* write time */
5234                         put_long_date_timespec(conn->ts_res,pdata+24,ctime_ts); /* change time */
5235                         SIVAL(pdata,32,mode);
5236                         SIVAL(pdata,36,0); /* padding. */
5237                         pdata += 40;
5238                         SOFF_T(pdata,0,allocation_size);
5239                         SOFF_T(pdata,8,file_size);
5240                         SIVAL(pdata,16,nlink);
5241                         SCVAL(pdata,20,delete_pending);
5242                         SCVAL(pdata,21,(mode&FILE_ATTRIBUTE_DIRECTORY)?1:0);
5243                         SSVAL(pdata,22,0);
5244                         pdata += 24;
5245                         SIVAL(pdata,0,ea_size);
5246                         pdata += 4; /* EA info */
5247                         status = srvstr_push(dstart, flags2,
5248                                           pdata+4, dos_fname,
5249                                           PTR_DIFF(dend, pdata+4),
5250                                           STR_UNICODE, &len);
5251                         if (!NT_STATUS_IS_OK(status)) {
5252                                 return status;
5253                         }
5254                         SIVAL(pdata,0,len);
5255                         pdata += 4 + len;
5256                         data_size = PTR_DIFF(pdata,(*ppdata));
5257                         *fixed_portion = 10;
5258                         break;
5259                 }
5260
5261                 case 0xFF12:/*SMB2_FILE_ALL_INFORMATION*/
5262                 {
5263                         unsigned int ea_size =
5264                             estimate_ea_size(conn, fsp, smb_fname);
5265                         DEBUG(10,("smbd_do_qfilepathinfo: SMB2_FILE_ALL_INFORMATION\n"));
5266                         put_long_date_timespec(conn->ts_res,pdata+0x00,create_time_ts);
5267                         put_long_date_timespec(conn->ts_res,pdata+0x08,atime_ts);
5268                         put_long_date_timespec(conn->ts_res,pdata+0x10,mtime_ts); /* write time */
5269                         put_long_date_timespec(conn->ts_res,pdata+0x18,ctime_ts); /* change time */
5270                         SIVAL(pdata,    0x20, mode);
5271                         SIVAL(pdata,    0x24, 0); /* padding. */
5272                         SBVAL(pdata,    0x28, allocation_size);
5273                         SBVAL(pdata,    0x30, file_size);
5274                         SIVAL(pdata,    0x38, nlink);
5275                         SCVAL(pdata,    0x3C, delete_pending);
5276                         SCVAL(pdata,    0x3D, (mode&FILE_ATTRIBUTE_DIRECTORY)?1:0);
5277                         SSVAL(pdata,    0x3E, 0); /* padding */
5278                         SBVAL(pdata,    0x40, file_index);
5279                         SIVAL(pdata,    0x48, ea_size);
5280                         SIVAL(pdata,    0x4C, access_mask);
5281                         SBVAL(pdata,    0x50, pos);
5282                         SIVAL(pdata,    0x58, mode); /*TODO: mode != mode fix this!!! */
5283                         SIVAL(pdata,    0x5C, 0); /* No alignment needed. */
5284
5285                         pdata += 0x60;
5286
5287                         status = srvstr_push(dstart, flags2,
5288                                           pdata+4, dos_fname,
5289                                           PTR_DIFF(dend, pdata+4),
5290                                           STR_UNICODE, &len);
5291                         if (!NT_STATUS_IS_OK(status)) {
5292                                 return status;
5293                         }
5294                         SIVAL(pdata,0,len);
5295                         pdata += 4 + len;
5296                         data_size = PTR_DIFF(pdata,(*ppdata));
5297                         *fixed_portion = 104;
5298                         break;
5299                 }
5300                 case SMB_FILE_INTERNAL_INFORMATION:
5301
5302                         DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_INTERNAL_INFORMATION\n"));
5303                         SBVAL(pdata, 0, file_index);
5304                         data_size = 8;
5305                         *fixed_portion = 8;
5306                         break;
5307
5308                 case SMB_FILE_ACCESS_INFORMATION:
5309                         DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_ACCESS_INFORMATION\n"));
5310                         SIVAL(pdata, 0, access_mask);
5311                         data_size = 4;
5312                         *fixed_portion = 4;
5313                         break;
5314
5315                 case SMB_FILE_NAME_INFORMATION:
5316                         /* Pathname with leading '\'. */
5317                         {
5318                                 size_t byte_len;
5319                                 byte_len = dos_PutUniCode(pdata+4,dos_fname,(size_t)max_data_bytes,False);
5320                                 DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_NAME_INFORMATION\n"));
5321                                 SIVAL(pdata,0,byte_len);
5322                                 data_size = 4 + byte_len;
5323                                 break;
5324                         }
5325
5326                 case SMB_FILE_DISPOSITION_INFORMATION:
5327                         DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_DISPOSITION_INFORMATION\n"));
5328                         data_size = 1;
5329                         SCVAL(pdata,0,delete_pending);
5330                         *fixed_portion = 1;
5331                         break;
5332
5333                 case SMB_FILE_POSITION_INFORMATION:
5334                         DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_POSITION_INFORMATION\n"));
5335                         data_size = 8;
5336                         SOFF_T(pdata,0,pos);
5337                         *fixed_portion = 8;
5338                         break;
5339
5340                 case SMB_FILE_MODE_INFORMATION:
5341                         DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_MODE_INFORMATION\n"));
5342                         SIVAL(pdata,0,mode);
5343                         data_size = 4;
5344                         *fixed_portion = 4;
5345                         break;
5346
5347                 case SMB_FILE_ALIGNMENT_INFORMATION:
5348                         DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_ALIGNMENT_INFORMATION\n"));
5349                         SIVAL(pdata,0,0); /* No alignment needed. */
5350                         data_size = 4;
5351                         *fixed_portion = 4;
5352                         break;
5353
5354                 /*
5355                  * NT4 server just returns "invalid query" to this - if we try
5356                  * to answer it then NTws gets a BSOD! (tridge).  W2K seems to
5357                  * want this. JRA.
5358                  */
5359                 /* The first statement above is false - verified using Thursby
5360                  * client against NT4 -- gcolley.
5361                  */
5362                 case SMB_QUERY_FILE_STREAM_INFO:
5363                 case SMB_FILE_STREAM_INFORMATION: {
5364                         unsigned int num_streams = 0;
5365                         struct stream_struct *streams = NULL;
5366
5367                         DEBUG(10,("smbd_do_qfilepathinfo: "
5368                                   "SMB_FILE_STREAM_INFORMATION\n"));
5369
5370                         if (is_ntfs_stream_smb_fname(smb_fname)) {
5371                                 return NT_STATUS_INVALID_PARAMETER;
5372                         }
5373
5374                         status = vfs_streaminfo(conn,
5375                                                 fsp,
5376                                                 smb_fname,
5377                                                 talloc_tos(),
5378                                                 &num_streams,
5379                                                 &streams);
5380
5381                         if (!NT_STATUS_IS_OK(status)) {
5382                                 DEBUG(10, ("could not get stream info: %s\n",
5383                                            nt_errstr(status)));
5384                                 return status;
5385                         }
5386
5387                         status = marshall_stream_info(num_streams, streams,
5388                                                       pdata, max_data_bytes,
5389                                                       &data_size);
5390
5391                         if (!NT_STATUS_IS_OK(status)) {
5392                                 DEBUG(10, ("marshall_stream_info failed: %s\n",
5393                                            nt_errstr(status)));
5394                                 TALLOC_FREE(streams);
5395                                 return status;
5396                         }
5397
5398                         TALLOC_FREE(streams);
5399
5400                         *fixed_portion = 32;
5401
5402                         break;
5403                 }
5404                 case SMB_QUERY_COMPRESSION_INFO:
5405                 case SMB_FILE_COMPRESSION_INFORMATION:
5406                         DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_COMPRESSION_INFORMATION\n"));
5407                         SOFF_T(pdata,0,file_size);
5408                         SIVAL(pdata,8,0); /* ??? */
5409                         SIVAL(pdata,12,0); /* ??? */
5410                         data_size = 16;
5411                         *fixed_portion = 16;
5412                         break;
5413
5414                 case SMB_FILE_NETWORK_OPEN_INFORMATION:
5415                         DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_NETWORK_OPEN_INFORMATION\n"));
5416                         put_long_date_timespec(conn->ts_res,pdata,create_time_ts);
5417                         put_long_date_timespec(conn->ts_res,pdata+8,atime_ts);
5418                         put_long_date_timespec(conn->ts_res,pdata+16,mtime_ts); /* write time */
5419                         put_long_date_timespec(conn->ts_res,pdata+24,ctime_ts); /* change time */
5420                         SOFF_T(pdata,32,allocation_size);
5421                         SOFF_T(pdata,40,file_size);
5422                         SIVAL(pdata,48,mode);
5423                         SIVAL(pdata,52,0); /* ??? */
5424                         data_size = 56;
5425                         *fixed_portion = 56;
5426                         break;
5427
5428                 case SMB_FILE_ATTRIBUTE_TAG_INFORMATION:
5429                         DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_ATTRIBUTE_TAG_INFORMATION\n"));
5430                         SIVAL(pdata,0,mode);
5431                         SIVAL(pdata,4,0);
5432                         data_size = 8;
5433                         *fixed_portion = 8;
5434                         break;
5435
5436                 /*
5437                  * CIFS UNIX Extensions.
5438                  */
5439
5440                 case SMB_QUERY_FILE_UNIX_BASIC:
5441
5442                         pdata = store_file_unix_basic(conn, pdata, fsp, psbuf);
5443                         data_size = PTR_DIFF(pdata,(*ppdata));
5444
5445                         DEBUG(4,("smbd_do_qfilepathinfo: "
5446                                  "SMB_QUERY_FILE_UNIX_BASIC\n"));
5447                         dump_data(4, (uint8_t *)(*ppdata), data_size);
5448
5449                         break;
5450
5451                 case SMB_QUERY_FILE_UNIX_INFO2:
5452
5453                         pdata = store_file_unix_basic_info2(conn, pdata, fsp, psbuf);
5454                         data_size = PTR_DIFF(pdata,(*ppdata));
5455
5456                         {
5457                                 int i;
5458                                 DEBUG(4,("smbd_do_qfilepathinfo: SMB_QUERY_FILE_UNIX_INFO2 "));
5459
5460                                 for (i=0; i<100; i++)
5461                                         DEBUG(4,("%d=%x, ",i, (*ppdata)[i]));
5462                                 DEBUG(4,("\n"));
5463                         }
5464
5465                         break;
5466
5467                 case SMB_QUERY_FILE_UNIX_LINK:
5468                         {
5469                                 int link_len = 0;
5470                                 char *buffer = talloc_array(mem_ctx, char, PATH_MAX+1);
5471
5472                                 if (!buffer) {
5473                                         return NT_STATUS_NO_MEMORY;
5474                                 }
5475
5476                                 DEBUG(10,("smbd_do_qfilepathinfo: SMB_QUERY_FILE_UNIX_LINK\n"));
5477 #ifdef S_ISLNK
5478                                 if(!S_ISLNK(psbuf->st_ex_mode)) {
5479                                         return NT_STATUS_DOS(ERRSRV, ERRbadlink);
5480                                 }
5481 #else
5482                                 return NT_STATUS_DOS(ERRDOS, ERRbadlink);
5483 #endif
5484                                 link_len = SMB_VFS_READLINK(conn,
5485                                                        smb_fname,
5486                                                        buffer, PATH_MAX);
5487                                 if (link_len == -1) {
5488                                         return map_nt_error_from_unix(errno);
5489                                 }
5490                                 buffer[link_len] = 0;
5491                                 status = srvstr_push(dstart, flags2,
5492                                                   pdata, buffer,
5493                                                   PTR_DIFF(dend, pdata),
5494                                                   STR_TERMINATE, &len);
5495                                 if (!NT_STATUS_IS_OK(status)) {
5496                                         return status;
5497                                 }
5498                                 pdata += len;
5499                                 data_size = PTR_DIFF(pdata,(*ppdata));
5500
5501                                 break;
5502                         }
5503
5504 #if defined(HAVE_POSIX_ACLS)
5505                 case SMB_QUERY_POSIX_ACL:
5506                         {
5507                                 SMB_ACL_T file_acl = NULL;
5508                                 SMB_ACL_T def_acl = NULL;
5509                                 uint16_t num_file_acls = 0;
5510                                 uint16_t num_def_acls = 0;
5511
5512                                 status = refuse_symlink(conn,
5513                                                 fsp,
5514                                                 smb_fname);
5515                                 if (!NT_STATUS_IS_OK(status)) {
5516                                         return status;
5517                                 }
5518
5519                                 if (fsp && fsp->fh->fd != -1) {
5520                                         file_acl = SMB_VFS_SYS_ACL_GET_FD(fsp,
5521                                                 talloc_tos());
5522                                 } else {
5523                                         file_acl =
5524                                             SMB_VFS_SYS_ACL_GET_FILE(conn,
5525                                                 smb_fname,
5526                                                 SMB_ACL_TYPE_ACCESS,
5527                                                 talloc_tos());
5528                                 }
5529
5530                                 if (file_acl == NULL && no_acl_syscall_error(errno)) {
5531                                         DEBUG(5,("smbd_do_qfilepathinfo: ACLs "
5532                                                  "not implemented on "
5533                                                  "filesystem containing %s\n",
5534                                                  smb_fname->base_name));
5535                                         return NT_STATUS_NOT_IMPLEMENTED;
5536                                 }
5537
5538                                 if (S_ISDIR(psbuf->st_ex_mode)) {
5539                                         if (fsp && fsp->is_directory) {
5540                                                 def_acl =
5541                                                     SMB_VFS_SYS_ACL_GET_FILE(
5542                                                             conn,
5543                                                             fsp->fsp_name,
5544                                                             SMB_ACL_TYPE_DEFAULT,
5545                                                             talloc_tos());
5546                                         } else {
5547                                                 def_acl =
5548                                                     SMB_VFS_SYS_ACL_GET_FILE(
5549                                                             conn,
5550                                                             smb_fname,
5551                                                             SMB_ACL_TYPE_DEFAULT,
5552                                                             talloc_tos());
5553                                         }
5554                                         def_acl = free_empty_sys_acl(conn, def_acl);
5555                                 }
5556
5557                                 num_file_acls = count_acl_entries(conn, file_acl);
5558                                 num_def_acls = count_acl_entries(conn, def_acl);
5559
5560                                 if ( data_size < (num_file_acls + num_def_acls)*SMB_POSIX_ACL_ENTRY_SIZE + SMB_POSIX_ACL_HEADER_SIZE) {
5561                                         DEBUG(5,("smbd_do_qfilepathinfo: data_size too small (%u) need %u\n",
5562                                                 data_size,
5563                                                 (unsigned int)((num_file_acls + num_def_acls)*SMB_POSIX_ACL_ENTRY_SIZE +
5564                                                         SMB_POSIX_ACL_HEADER_SIZE) ));
5565                                         if (file_acl) {
5566                                                 TALLOC_FREE(file_acl);
5567                                         }
5568                                         if (def_acl) {
5569                                                 TALLOC_FREE(def_acl);
5570                                         }
5571                                         return NT_STATUS_BUFFER_TOO_SMALL;
5572                                 }
5573
5574                                 SSVAL(pdata,0,SMB_POSIX_ACL_VERSION);
5575                                 SSVAL(pdata,2,num_file_acls);
5576                                 SSVAL(pdata,4,num_def_acls);
5577                                 if (!marshall_posix_acl(conn, pdata + SMB_POSIX_ACL_HEADER_SIZE, psbuf, file_acl)) {
5578                                         if (file_acl) {
5579                                                 TALLOC_FREE(file_acl);
5580                                         }
5581                                         if (def_acl) {
5582                                                 TALLOC_FREE(def_acl);
5583                                         }
5584                                         return NT_STATUS_INTERNAL_ERROR;
5585                                 }
5586                                 if (!marshall_posix_acl(conn, pdata + SMB_POSIX_ACL_HEADER_SIZE + (num_file_acls*SMB_POSIX_ACL_ENTRY_SIZE), psbuf, def_acl)) {
5587                                         if (file_acl) {
5588                                                 TALLOC_FREE(file_acl);
5589                                         }
5590                                         if (def_acl) {
5591                                                 TALLOC_FREE(def_acl);
5592                                         }
5593                                         return NT_STATUS_INTERNAL_ERROR;
5594                                 }
5595
5596                                 if (file_acl) {
5597                                         TALLOC_FREE(file_acl);
5598                                 }
5599                                 if (def_acl) {
5600                                         TALLOC_FREE(def_acl);
5601                                 }
5602                                 data_size = (num_file_acls + num_def_acls)*SMB_POSIX_ACL_ENTRY_SIZE + SMB_POSIX_ACL_HEADER_SIZE;
5603                                 break;
5604                         }
5605 #endif
5606
5607
5608                 case SMB_QUERY_POSIX_LOCK:
5609                 {
5610                         uint64_t count;
5611                         uint64_t offset;
5612                         uint64_t smblctx;
5613                         enum brl_type lock_type;
5614
5615                         /* We need an open file with a real fd for this. */
5616                         if (!fsp || fsp->fh->fd == -1) {
5617                                 return NT_STATUS_INVALID_LEVEL;
5618                         }
5619
5620                         if (lock_data_count != POSIX_LOCK_DATA_SIZE) {
5621                                 return NT_STATUS_INVALID_PARAMETER;
5622                         }
5623
5624                         switch (SVAL(pdata, POSIX_LOCK_TYPE_OFFSET)) {
5625                                 case POSIX_LOCK_TYPE_READ:
5626                                         lock_type = READ_LOCK;
5627                                         break;
5628                                 case POSIX_LOCK_TYPE_WRITE:
5629                                         lock_type = WRITE_LOCK;
5630                                         break;
5631                                 case POSIX_LOCK_TYPE_UNLOCK:
5632                                 default:
5633                                         /* There's no point in asking for an unlock... */
5634                                         return NT_STATUS_INVALID_PARAMETER;
5635                         }
5636
5637                         smblctx = (uint64_t)IVAL(pdata, POSIX_LOCK_PID_OFFSET);
5638                         offset = BVAL(pdata,POSIX_LOCK_START_OFFSET);
5639                         count = BVAL(pdata,POSIX_LOCK_LEN_OFFSET);
5640
5641                         status = query_lock(fsp,
5642                                         &smblctx,
5643                                         &count,
5644                                         &offset,
5645                                         &lock_type,
5646                                         POSIX_LOCK);
5647
5648                         if (ERROR_WAS_LOCK_DENIED(status)) {
5649                                 /* Here we need to report who has it locked... */
5650                                 data_size = POSIX_LOCK_DATA_SIZE;
5651
5652                                 SSVAL(pdata, POSIX_LOCK_TYPE_OFFSET, lock_type);
5653                                 SSVAL(pdata, POSIX_LOCK_FLAGS_OFFSET, 0);
5654                                 SIVAL(pdata, POSIX_LOCK_PID_OFFSET, (uint32_t)smblctx);
5655                                 SBVAL(pdata, POSIX_LOCK_START_OFFSET, offset);
5656                                 SBVAL(pdata, POSIX_LOCK_LEN_OFFSET, count);
5657
5658                         } else if (NT_STATUS_IS_OK(status)) {
5659                                 /* For success we just return a copy of what we sent
5660                                    with the lock type set to POSIX_LOCK_TYPE_UNLOCK. */
5661                                 data_size = POSIX_LOCK_DATA_SIZE;
5662                                 memcpy(pdata, lock_data, POSIX_LOCK_DATA_SIZE);
5663                                 SSVAL(pdata, POSIX_LOCK_TYPE_OFFSET, POSIX_LOCK_TYPE_UNLOCK);
5664                         } else {
5665                                 return status;
5666                         }
5667                         break;
5668                 }
5669
5670                 default:
5671                         return NT_STATUS_INVALID_LEVEL;
5672         }
5673
5674         *pdata_size = data_size;
5675         return NT_STATUS_OK;
5676 }
5677
5678 /****************************************************************************
5679  Reply to a TRANS2_QFILEPATHINFO or TRANSACT2_QFILEINFO (query file info by
5680  file name or file id).
5681 ****************************************************************************/
5682
5683 static void call_trans2qfilepathinfo(connection_struct *conn,
5684                                      struct smb_request *req,
5685                                      unsigned int tran_call,
5686                                      char **pparams, int total_params,
5687                                      char **ppdata, int total_data,
5688                                      unsigned int max_data_bytes)
5689 {
5690         char *params = *pparams;
5691         char *pdata = *ppdata;
5692         uint16_t info_level;
5693         unsigned int data_size = 0;
5694         unsigned int param_size = 2;
5695         struct smb_filename *smb_fname = NULL;
5696         bool delete_pending = False;
5697         struct timespec write_time_ts;
5698         files_struct *fsp = NULL;
5699         struct file_id fileid;
5700         struct ea_list *ea_list = NULL;
5701         int lock_data_count = 0;
5702         char *lock_data = NULL;
5703         size_t fixed_portion;
5704         NTSTATUS status = NT_STATUS_OK;
5705
5706         if (!params) {
5707                 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
5708                 return;
5709         }
5710
5711         ZERO_STRUCT(write_time_ts);
5712
5713         if (tran_call == TRANSACT2_QFILEINFO) {
5714                 if (total_params < 4) {
5715                         reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
5716                         return;
5717                 }
5718
5719                 if (IS_IPC(conn)) {
5720                         call_trans2qpipeinfo(conn, req, tran_call,
5721                                              pparams, total_params,
5722                                              ppdata, total_data,
5723                                              max_data_bytes);
5724                         return;
5725                 }
5726
5727                 fsp = file_fsp(req, SVAL(params,0));
5728                 info_level = SVAL(params,2);
5729
5730                 DEBUG(3,("call_trans2qfilepathinfo: TRANSACT2_QFILEINFO: level = %d\n", info_level));
5731
5732                 if (INFO_LEVEL_IS_UNIX(info_level) && !lp_unix_extensions()) {
5733                         reply_nterror(req, NT_STATUS_INVALID_LEVEL);
5734                         return;
5735                 }
5736
5737                 /* Initial check for valid fsp ptr. */
5738                 if (!check_fsp_open(conn, req, fsp)) {
5739                         return;
5740                 }
5741
5742                 smb_fname = cp_smb_filename(talloc_tos(), fsp->fsp_name);
5743                 if (smb_fname == NULL) {
5744                         reply_nterror(req, NT_STATUS_NO_MEMORY);
5745                         return;
5746                 }
5747
5748                 if(fsp->fake_file_handle) {
5749                         /*
5750                          * This is actually for the QUOTA_FAKE_FILE --metze
5751                          */
5752
5753                         /* We know this name is ok, it's already passed the checks. */
5754
5755                 } else if(fsp->fh->fd == -1) {
5756                         /*
5757                          * This is actually a QFILEINFO on a directory
5758                          * handle (returned from an NT SMB). NT5.0 seems
5759                          * to do this call. JRA.
5760                          */
5761
5762                         if (INFO_LEVEL_IS_UNIX(info_level)) {
5763                                 /* Always do lstat for UNIX calls. */
5764                                 if (SMB_VFS_LSTAT(conn, smb_fname)) {
5765                                         DEBUG(3,("call_trans2qfilepathinfo: "
5766                                                  "SMB_VFS_LSTAT of %s failed "
5767                                                  "(%s)\n",
5768                                                  smb_fname_str_dbg(smb_fname),
5769                                                  strerror(errno)));
5770                                         reply_nterror(req,
5771                                                 map_nt_error_from_unix(errno));
5772                                         return;
5773                                 }
5774                         } else if (SMB_VFS_STAT(conn, smb_fname)) {
5775                                 DEBUG(3,("call_trans2qfilepathinfo: "
5776                                          "SMB_VFS_STAT of %s failed (%s)\n",
5777                                          smb_fname_str_dbg(smb_fname),
5778                                          strerror(errno)));
5779                                 reply_nterror(req,
5780                                         map_nt_error_from_unix(errno));
5781                                 return;
5782                         }
5783
5784                         fileid = vfs_file_id_from_sbuf(conn, &smb_fname->st);
5785                         get_file_infos(fileid, fsp->name_hash, &delete_pending, &write_time_ts);
5786                 } else {
5787                         /*
5788                          * Original code - this is an open file.
5789                          */
5790                         if (SMB_VFS_FSTAT(fsp, &smb_fname->st) != 0) {
5791                                 DEBUG(3, ("fstat of %s failed (%s)\n",
5792                                           fsp_fnum_dbg(fsp), strerror(errno)));
5793                                 reply_nterror(req,
5794                                         map_nt_error_from_unix(errno));
5795                                 return;
5796                         }
5797                         fileid = vfs_file_id_from_sbuf(conn, &smb_fname->st);
5798                         get_file_infos(fileid, fsp->name_hash, &delete_pending, &write_time_ts);
5799                 }
5800
5801         } else {
5802                 uint32_t name_hash;
5803                 char *fname = NULL;
5804                 uint32_t ucf_flags = ucf_flags_from_smb_request(req);
5805
5806                 /* qpathinfo */
5807                 if (total_params < 7) {
5808                         reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
5809                         return;
5810                 }
5811
5812                 info_level = SVAL(params,0);
5813
5814                 DEBUG(3,("call_trans2qfilepathinfo: TRANSACT2_QPATHINFO: level = %d\n", info_level));
5815
5816                 if (INFO_LEVEL_IS_UNIX(info_level)) {
5817                         if (!lp_unix_extensions()) {
5818                                 reply_nterror(req, NT_STATUS_INVALID_LEVEL);
5819                                 return;
5820                         }
5821                         if (info_level == SMB_QUERY_FILE_UNIX_BASIC ||
5822                                         info_level == SMB_QUERY_FILE_UNIX_INFO2 ||
5823                                         info_level == SMB_QUERY_FILE_UNIX_LINK ||
5824                                         req->posix_pathnames) {
5825                                 ucf_flags |= UCF_UNIX_NAME_LOOKUP;
5826                         }
5827                 }
5828
5829                 if (req->posix_pathnames) {
5830                         srvstr_get_path_posix(req,
5831                                 params,
5832                                 req->flags2,
5833                                 &fname,
5834                                 &params[6],
5835                                 total_params - 6,
5836                                 STR_TERMINATE,
5837                                 &status);
5838                 } else {
5839                         srvstr_get_path(req,
5840                                 params,
5841                                 req->flags2,
5842                                 &fname,
5843                                 &params[6],
5844                                 total_params - 6,
5845                                 STR_TERMINATE,
5846                                 &status);
5847                 }
5848                 if (!NT_STATUS_IS_OK(status)) {
5849                         reply_nterror(req, status);
5850                         return;
5851                 }
5852
5853                 status = filename_convert(req,
5854                                         conn,
5855                                         fname,
5856                                         ucf_flags,
5857                                         NULL,
5858                                         &smb_fname);
5859                 if (!NT_STATUS_IS_OK(status)) {
5860                         if (NT_STATUS_EQUAL(status,NT_STATUS_PATH_NOT_COVERED)) {
5861                                 reply_botherror(req,
5862                                                 NT_STATUS_PATH_NOT_COVERED,
5863                                                 ERRSRV, ERRbadpath);
5864                                 return;
5865                         }
5866                         reply_nterror(req, status);
5867                         return;
5868                 }
5869
5870                 /* If this is a stream, check if there is a delete_pending. */
5871                 if ((conn->fs_capabilities & FILE_NAMED_STREAMS)
5872                     && is_ntfs_stream_smb_fname(smb_fname)) {
5873                         struct smb_filename *smb_fname_base;
5874
5875                         /* Create an smb_filename with stream_name == NULL. */
5876                         smb_fname_base = synthetic_smb_fname(
5877                                                 talloc_tos(),
5878                                                 smb_fname->base_name,
5879                                                 NULL,
5880                                                 NULL,
5881                                                 smb_fname->flags);
5882                         if (smb_fname_base == NULL) {
5883                                 reply_nterror(req, NT_STATUS_NO_MEMORY);
5884                                 return;
5885                         }
5886
5887                         if (INFO_LEVEL_IS_UNIX(info_level) || req->posix_pathnames) {
5888                                 /* Always do lstat for UNIX calls. */
5889                                 if (SMB_VFS_LSTAT(conn, smb_fname_base) != 0) {
5890                                         DEBUG(3,("call_trans2qfilepathinfo: "
5891                                                  "SMB_VFS_LSTAT of %s failed "
5892                                                  "(%s)\n",
5893                                                  smb_fname_str_dbg(smb_fname_base),
5894                                                  strerror(errno)));
5895                                         TALLOC_FREE(smb_fname_base);
5896                                         reply_nterror(req,
5897                                                 map_nt_error_from_unix(errno));
5898                                         return;
5899                                 }
5900                         } else {
5901                                 if (SMB_VFS_STAT(conn, smb_fname_base) != 0) {
5902                                         DEBUG(3,("call_trans2qfilepathinfo: "
5903                                                  "fileinfo of %s failed "
5904                                                  "(%s)\n",
5905                                                  smb_fname_str_dbg(smb_fname_base),
5906                                                  strerror(errno)));
5907                                         TALLOC_FREE(smb_fname_base);
5908                                         reply_nterror(req,
5909                                                 map_nt_error_from_unix(errno));
5910                                         return;
5911                                 }
5912                         }
5913
5914                         status = file_name_hash(conn,
5915                                         smb_fname_str_dbg(smb_fname_base),
5916                                         &name_hash);
5917                         if (!NT_STATUS_IS_OK(status)) {
5918                                 TALLOC_FREE(smb_fname_base);
5919                                 reply_nterror(req, status);
5920                                 return;
5921                         }
5922
5923                         fileid = vfs_file_id_from_sbuf(conn,
5924                                                        &smb_fname_base->st);
5925                         TALLOC_FREE(smb_fname_base);
5926                         get_file_infos(fileid, name_hash, &delete_pending, NULL);
5927                         if (delete_pending) {
5928                                 reply_nterror(req, NT_STATUS_DELETE_PENDING);
5929                                 return;
5930                         }
5931                 }
5932
5933                 if (INFO_LEVEL_IS_UNIX(info_level) || req->posix_pathnames) {
5934                         /* Always do lstat for UNIX calls. */
5935                         if (SMB_VFS_LSTAT(conn, smb_fname)) {
5936                                 DEBUG(3,("call_trans2qfilepathinfo: "
5937                                          "SMB_VFS_LSTAT of %s failed (%s)\n",
5938                                          smb_fname_str_dbg(smb_fname),
5939                                          strerror(errno)));
5940                                 reply_nterror(req,
5941                                         map_nt_error_from_unix(errno));
5942                                 return;
5943                         }
5944
5945                 } else {
5946                         if (SMB_VFS_STAT(conn, smb_fname) != 0) {
5947                                 DEBUG(3,("call_trans2qfilepathinfo: "
5948                                          "SMB_VFS_STAT of %s failed (%s)\n",
5949                                          smb_fname_str_dbg(smb_fname),
5950                                          strerror(errno)));
5951                                 reply_nterror(req,
5952                                         map_nt_error_from_unix(errno));
5953                                 return;
5954                         }
5955                 }
5956
5957                 status = file_name_hash(conn,
5958                                 smb_fname_str_dbg(smb_fname),
5959                                 &name_hash);
5960                 if (!NT_STATUS_IS_OK(status)) {
5961                         reply_nterror(req, status);
5962                         return;
5963                 }
5964
5965                 fileid = vfs_file_id_from_sbuf(conn, &smb_fname->st);
5966                 get_file_infos(fileid, name_hash, &delete_pending, &write_time_ts);
5967                 if (delete_pending) {
5968                         reply_nterror(req, NT_STATUS_DELETE_PENDING);
5969                         return;
5970                 }
5971         }
5972
5973         DEBUG(3,("call_trans2qfilepathinfo %s (%s) level=%d call=%d "
5974                  "total_data=%d\n", smb_fname_str_dbg(smb_fname),
5975                  fsp_fnum_dbg(fsp),
5976                  info_level,tran_call,total_data));
5977
5978         /* Pull out any data sent here before we realloc. */
5979         switch (info_level) {
5980                 case SMB_INFO_QUERY_EAS_FROM_LIST:
5981                 {
5982                         /* Pull any EA list from the data portion. */
5983                         uint32_t ea_size;
5984
5985                         if (total_data < 4) {
5986                                 reply_nterror(
5987                                         req, NT_STATUS_INVALID_PARAMETER);
5988                                 return;
5989                         }
5990                         ea_size = IVAL(pdata,0);
5991
5992                         if (total_data > 0 && ea_size != total_data) {
5993                                 DEBUG(4,("call_trans2qfilepathinfo: Rejecting EA request with incorrect \
5994 total_data=%u (should be %u)\n", (unsigned int)total_data, (unsigned int)IVAL(pdata,0) ));
5995                                 reply_nterror(
5996                                         req, NT_STATUS_INVALID_PARAMETER);
5997                                 return;
5998                         }
5999
6000                         if (!lp_ea_support(SNUM(conn))) {
6001                                 reply_nterror(req, NT_STATUS_EAS_NOT_SUPPORTED);
6002                                 return;
6003                         }
6004
6005                         /* Pull out the list of names. */
6006                         ea_list = read_ea_name_list(req, pdata + 4, ea_size - 4);
6007                         if (!ea_list) {
6008                                 reply_nterror(
6009                                         req, NT_STATUS_INVALID_PARAMETER);
6010                                 return;
6011                         }
6012                         break;
6013                 }
6014
6015                 case SMB_QUERY_POSIX_LOCK:
6016                 {
6017                         if (fsp == NULL || fsp->fh->fd == -1) {
6018                                 reply_nterror(req, NT_STATUS_INVALID_HANDLE);
6019                                 return;
6020                         }
6021
6022                         if (total_data != POSIX_LOCK_DATA_SIZE) {
6023                                 reply_nterror(
6024                                         req, NT_STATUS_INVALID_PARAMETER);
6025                                 return;
6026                         }
6027
6028                         /* Copy the lock range data. */
6029                         lock_data = (char *)talloc_memdup(
6030                                 req, pdata, total_data);
6031                         if (!lock_data) {
6032                                 reply_nterror(req, NT_STATUS_NO_MEMORY);
6033                                 return;
6034                         }
6035                         lock_data_count = total_data;
6036                 }
6037                 default:
6038                         break;
6039         }
6040
6041         *pparams = (char *)SMB_REALLOC(*pparams,2);
6042         if (*pparams == NULL) {
6043                 reply_nterror(req, NT_STATUS_NO_MEMORY);
6044                 return;
6045         }
6046         params = *pparams;
6047         SSVAL(params,0,0);
6048
6049         /*
6050          * draft-leach-cifs-v1-spec-02.txt
6051          * 4.2.14 TRANS2_QUERY_PATH_INFORMATION: Get File Attributes given Path
6052          * says:
6053          *
6054          *  The requested information is placed in the Data portion of the
6055          *  transaction response. For the information levels greater than 0x100,
6056          *  the transaction response has 1 parameter word which should be
6057          *  ignored by the client.
6058          *
6059          * However Windows only follows this rule for the IS_NAME_VALID call.
6060          */
6061         switch (info_level) {
6062         case SMB_INFO_IS_NAME_VALID:
6063                 param_size = 0;
6064                 break;
6065         }
6066
6067         if ((info_level & 0xFF00) == 0xFF00) {
6068                 /*
6069                  * We use levels that start with 0xFF00
6070                  * internally to represent SMB2 specific levels
6071                  */
6072                 reply_nterror(req, NT_STATUS_INVALID_LEVEL);
6073                 return;
6074         }
6075
6076         status = smbd_do_qfilepathinfo(conn, req, info_level,
6077                                        fsp, smb_fname,
6078                                        delete_pending, write_time_ts,
6079                                        ea_list,
6080                                        lock_data_count, lock_data,
6081                                        req->flags2, max_data_bytes,
6082                                        &fixed_portion,
6083                                        ppdata, &data_size);
6084         if (!NT_STATUS_IS_OK(status)) {
6085                 reply_nterror(req, status);
6086                 return;
6087         }
6088         if (fixed_portion > max_data_bytes) {
6089                 reply_nterror(req, NT_STATUS_INFO_LENGTH_MISMATCH);
6090                 return;
6091         }
6092
6093         send_trans2_replies(conn, req, NT_STATUS_OK, params, param_size, *ppdata, data_size,
6094                             max_data_bytes);
6095
6096         return;
6097 }
6098
6099 /****************************************************************************
6100  Set a hard link (called by UNIX extensions and by NT rename with HARD link
6101  code.
6102 ****************************************************************************/
6103
6104 NTSTATUS hardlink_internals(TALLOC_CTX *ctx,
6105                 connection_struct *conn,
6106                 struct smb_request *req,
6107                 bool overwrite_if_exists,
6108                 const struct smb_filename *smb_fname_old,
6109                 struct smb_filename *smb_fname_new)
6110 {
6111         NTSTATUS status = NT_STATUS_OK;
6112
6113         /* source must already exist. */
6114         if (!VALID_STAT(smb_fname_old->st)) {
6115                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
6116         }
6117
6118         if (VALID_STAT(smb_fname_new->st)) {
6119                 if (overwrite_if_exists) {
6120                         if (S_ISDIR(smb_fname_new->st.st_ex_mode)) {
6121                                 return NT_STATUS_FILE_IS_A_DIRECTORY;
6122                         }
6123                         status = unlink_internals(conn,
6124                                                 req,
6125                                                 FILE_ATTRIBUTE_NORMAL,
6126                                                 smb_fname_new,
6127                                                 false);
6128                         if (!NT_STATUS_IS_OK(status)) {
6129                                 return status;
6130                         }
6131                 } else {
6132                         /* Disallow if newname already exists. */
6133                         return NT_STATUS_OBJECT_NAME_COLLISION;
6134                 }
6135         }
6136
6137         /* No links from a directory. */
6138         if (S_ISDIR(smb_fname_old->st.st_ex_mode)) {
6139                 return NT_STATUS_FILE_IS_A_DIRECTORY;
6140         }
6141
6142         /* Setting a hardlink to/from a stream isn't currently supported. */
6143         if (is_ntfs_stream_smb_fname(smb_fname_old) ||
6144             is_ntfs_stream_smb_fname(smb_fname_new)) {
6145                 return NT_STATUS_INVALID_PARAMETER;
6146         }
6147
6148         DEBUG(10,("hardlink_internals: doing hard link %s -> %s\n",
6149                   smb_fname_old->base_name, smb_fname_new->base_name));
6150
6151         if (SMB_VFS_LINK(conn, smb_fname_old, smb_fname_new) != 0) {
6152                 status = map_nt_error_from_unix(errno);
6153                 DEBUG(3,("hardlink_internals: Error %s hard link %s -> %s\n",
6154                          nt_errstr(status), smb_fname_old->base_name,
6155                          smb_fname_new->base_name));
6156         }
6157         return status;
6158 }
6159
6160 /****************************************************************************
6161  Deal with setting the time from any of the setfilepathinfo functions.
6162  NOTE !!!! The check for FILE_WRITE_ATTRIBUTES access must be done *before*
6163  calling this function.
6164 ****************************************************************************/
6165
6166 NTSTATUS smb_set_file_time(connection_struct *conn,
6167                            files_struct *fsp,
6168                            const struct smb_filename *smb_fname,
6169                            struct smb_file_time *ft,
6170                            bool setting_write_time)
6171 {
6172         struct smb_filename smb_fname_base;
6173         uint32_t action =
6174                 FILE_NOTIFY_CHANGE_LAST_ACCESS
6175                 |FILE_NOTIFY_CHANGE_LAST_WRITE
6176                 |FILE_NOTIFY_CHANGE_CREATION;
6177
6178         if (!VALID_STAT(smb_fname->st)) {
6179                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
6180         }
6181
6182         /* get some defaults (no modifications) if any info is zero or -1. */
6183         if (null_timespec(ft->create_time)) {
6184                 action &= ~FILE_NOTIFY_CHANGE_CREATION;
6185         }
6186
6187         if (null_timespec(ft->atime)) {
6188                 action &= ~FILE_NOTIFY_CHANGE_LAST_ACCESS;
6189         }
6190
6191         if (null_timespec(ft->mtime)) {
6192                 action &= ~FILE_NOTIFY_CHANGE_LAST_WRITE;
6193         }
6194
6195         if (!setting_write_time) {
6196                 /* ft->mtime comes from change time, not write time. */
6197                 action &= ~FILE_NOTIFY_CHANGE_LAST_WRITE;
6198         }
6199
6200         /* Ensure the resolution is the correct for
6201          * what we can store on this filesystem. */
6202
6203         round_timespec(conn->ts_res, &ft->create_time);
6204         round_timespec(conn->ts_res, &ft->ctime);
6205         round_timespec(conn->ts_res, &ft->atime);
6206         round_timespec(conn->ts_res, &ft->mtime);
6207
6208         DEBUG(5,("smb_set_filetime: actime: %s\n ",
6209                 time_to_asc(convert_timespec_to_time_t(ft->atime))));
6210         DEBUG(5,("smb_set_filetime: modtime: %s\n ",
6211                 time_to_asc(convert_timespec_to_time_t(ft->mtime))));
6212         DEBUG(5,("smb_set_filetime: ctime: %s\n ",
6213                 time_to_asc(convert_timespec_to_time_t(ft->ctime))));
6214         DEBUG(5,("smb_set_file_time: createtime: %s\n ",
6215                 time_to_asc(convert_timespec_to_time_t(ft->create_time))));
6216
6217         if (setting_write_time) {
6218                 /*
6219                  * This was a Windows setfileinfo on an open file.
6220                  * NT does this a lot. We also need to
6221                  * set the time here, as it can be read by
6222                  * FindFirst/FindNext and with the patch for bug #2045
6223                  * in smbd/fileio.c it ensures that this timestamp is
6224                  * kept sticky even after a write. We save the request
6225                  * away and will set it on file close and after a write. JRA.
6226                  */
6227
6228                 DEBUG(10,("smb_set_file_time: setting pending modtime to %s\n",
6229                           time_to_asc(convert_timespec_to_time_t(ft->mtime))));
6230
6231                 if (fsp != NULL) {
6232                         if (fsp->base_fsp) {
6233                                 set_sticky_write_time_fsp(fsp->base_fsp,
6234                                                           ft->mtime);
6235                         } else {
6236                                 set_sticky_write_time_fsp(fsp, ft->mtime);
6237                         }
6238                 } else {
6239                         set_sticky_write_time_path(
6240                                 vfs_file_id_from_sbuf(conn, &smb_fname->st),
6241                                 ft->mtime);
6242                 }
6243         }
6244
6245         DEBUG(10,("smb_set_file_time: setting utimes to modified values.\n"));
6246
6247         /* Always call ntimes on the base, even if a stream was passed in. */
6248         smb_fname_base = *smb_fname;
6249         smb_fname_base.stream_name = NULL;
6250
6251         if(file_ntimes(conn, &smb_fname_base, ft)!=0) {
6252                 return map_nt_error_from_unix(errno);
6253         }
6254
6255         notify_fname(conn, NOTIFY_ACTION_MODIFIED, action,
6256                      smb_fname->base_name);
6257         return NT_STATUS_OK;
6258 }
6259
6260 /****************************************************************************
6261  Deal with setting the dosmode from any of the setfilepathinfo functions.
6262  NB. The check for FILE_WRITE_ATTRIBUTES access on this path must have been
6263  done before calling this function.
6264 ****************************************************************************/
6265
6266 static NTSTATUS smb_set_file_dosmode(connection_struct *conn,
6267                                      const struct smb_filename *smb_fname,
6268                                      uint32_t dosmode)
6269 {
6270         struct smb_filename *smb_fname_base;
6271         NTSTATUS status;
6272
6273         if (!VALID_STAT(smb_fname->st)) {
6274                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
6275         }
6276
6277         /* Always operate on the base_name, even if a stream was passed in. */
6278         smb_fname_base = synthetic_smb_fname(talloc_tos(),
6279                                         smb_fname->base_name,
6280                                         NULL,
6281                                         &smb_fname->st,
6282                                         smb_fname->flags);
6283         if (smb_fname_base == NULL) {
6284                 return NT_STATUS_NO_MEMORY;
6285         }
6286
6287         if (dosmode) {
6288                 if (S_ISDIR(smb_fname_base->st.st_ex_mode)) {
6289                         dosmode |= FILE_ATTRIBUTE_DIRECTORY;
6290                 } else {
6291                         dosmode &= ~FILE_ATTRIBUTE_DIRECTORY;
6292                 }
6293         }
6294
6295         DEBUG(6,("smb_set_file_dosmode: dosmode: 0x%x\n", (unsigned int)dosmode));
6296
6297         /* check the mode isn't different, before changing it */
6298         if ((dosmode != 0) && (dosmode != dos_mode(conn, smb_fname_base))) {
6299                 DEBUG(10,("smb_set_file_dosmode: file %s : setting dos mode "
6300                           "0x%x\n", smb_fname_str_dbg(smb_fname_base),
6301                           (unsigned int)dosmode));
6302
6303                 if(file_set_dosmode(conn, smb_fname_base, dosmode, NULL,
6304                                     false)) {
6305                         DEBUG(2,("smb_set_file_dosmode: file_set_dosmode of "
6306                                  "%s failed (%s)\n",
6307                                  smb_fname_str_dbg(smb_fname_base),
6308                                  strerror(errno)));
6309                         status = map_nt_error_from_unix(errno);
6310                         goto out;
6311                 }
6312         }
6313         status = NT_STATUS_OK;
6314  out:
6315         TALLOC_FREE(smb_fname_base);
6316         return status;
6317 }
6318
6319 /****************************************************************************
6320  Deal with setting the size from any of the setfilepathinfo functions.
6321 ****************************************************************************/
6322
6323 static NTSTATUS smb_set_file_size(connection_struct *conn,
6324                                   struct smb_request *req,
6325                                   files_struct *fsp,
6326                                   const struct smb_filename *smb_fname,
6327                                   const SMB_STRUCT_STAT *psbuf,
6328                                   off_t size,
6329                                   bool fail_after_createfile)
6330 {
6331         NTSTATUS status = NT_STATUS_OK;
6332         struct smb_filename *smb_fname_tmp = NULL;
6333         files_struct *new_fsp = NULL;
6334
6335         if (!VALID_STAT(*psbuf)) {
6336                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
6337         }
6338
6339         DEBUG(6,("smb_set_file_size: size: %.0f ", (double)size));
6340
6341         if (size == get_file_size_stat(psbuf)) {
6342                 return NT_STATUS_OK;
6343         }
6344
6345         DEBUG(10,("smb_set_file_size: file %s : setting new size to %.0f\n",
6346                   smb_fname_str_dbg(smb_fname), (double)size));
6347
6348         if (fsp && fsp->fh->fd != -1) {
6349                 /* Handle based call. */
6350                 if (!(fsp->access_mask & FILE_WRITE_DATA)) {
6351                         return NT_STATUS_ACCESS_DENIED;
6352                 }
6353
6354                 if (vfs_set_filelen(fsp, size) == -1) {
6355                         return map_nt_error_from_unix(errno);
6356                 }
6357                 trigger_write_time_update_immediate(fsp);
6358                 return NT_STATUS_OK;
6359         }
6360
6361         smb_fname_tmp = cp_smb_filename(talloc_tos(), smb_fname);
6362         if (smb_fname_tmp == NULL) {
6363                 return NT_STATUS_NO_MEMORY;
6364         }
6365
6366         smb_fname_tmp->st = *psbuf;
6367
6368         status = SMB_VFS_CREATE_FILE(
6369                 conn,                                   /* conn */
6370                 req,                                    /* req */
6371                 0,                                      /* root_dir_fid */
6372                 smb_fname_tmp,                          /* fname */
6373                 FILE_WRITE_DATA,                        /* access_mask */
6374                 (FILE_SHARE_READ | FILE_SHARE_WRITE |   /* share_access */
6375                     FILE_SHARE_DELETE),
6376                 FILE_OPEN,                              /* create_disposition*/
6377                 0,                                      /* create_options */
6378                 FILE_ATTRIBUTE_NORMAL,                  /* file_attributes */
6379                 0,                                      /* oplock_request */
6380                 NULL,                                   /* lease */
6381                 0,                                      /* allocation_size */
6382                 0,                                      /* private_flags */
6383                 NULL,                                   /* sd */
6384                 NULL,                                   /* ea_list */
6385                 &new_fsp,                               /* result */
6386                 NULL,                                   /* pinfo */
6387                 NULL, NULL);                            /* create context */
6388
6389         TALLOC_FREE(smb_fname_tmp);
6390
6391         if (!NT_STATUS_IS_OK(status)) {
6392                 /* NB. We check for open_was_deferred in the caller. */
6393                 return status;
6394         }
6395
6396         /* See RAW-SFILEINFO-END-OF-FILE */
6397         if (fail_after_createfile) {
6398                 close_file(req, new_fsp,NORMAL_CLOSE);
6399                 return NT_STATUS_INVALID_LEVEL;
6400         }
6401
6402         if (vfs_set_filelen(new_fsp, size) == -1) {
6403                 status = map_nt_error_from_unix(errno);
6404                 close_file(req, new_fsp,NORMAL_CLOSE);
6405                 return status;
6406         }
6407
6408         trigger_write_time_update_immediate(new_fsp);
6409         close_file(req, new_fsp,NORMAL_CLOSE);
6410         return NT_STATUS_OK;
6411 }
6412
6413 /****************************************************************************
6414  Deal with SMB_INFO_SET_EA.
6415 ****************************************************************************/
6416
6417 static NTSTATUS smb_info_set_ea(connection_struct *conn,
6418                                 const char *pdata,
6419                                 int total_data,
6420                                 files_struct *fsp,
6421                                 const struct smb_filename *smb_fname)
6422 {
6423         struct ea_list *ea_list = NULL;
6424         TALLOC_CTX *ctx = NULL;
6425         NTSTATUS status = NT_STATUS_OK;
6426
6427         if (total_data < 10) {
6428
6429                 /* OS/2 workplace shell seems to send SET_EA requests of "null"
6430                    length. They seem to have no effect. Bug #3212. JRA */
6431
6432                 if ((total_data == 4) && (IVAL(pdata,0) == 4)) {
6433                         /* We're done. We only get EA info in this call. */
6434                         return NT_STATUS_OK;
6435                 }
6436
6437                 return NT_STATUS_INVALID_PARAMETER;
6438         }
6439
6440         if (IVAL(pdata,0) > total_data) {
6441                 DEBUG(10,("smb_info_set_ea: bad total data size (%u) > %u\n",
6442                         IVAL(pdata,0), (unsigned int)total_data));
6443                 return NT_STATUS_INVALID_PARAMETER;
6444         }
6445
6446         ctx = talloc_tos();
6447         ea_list = read_ea_list(ctx, pdata + 4, total_data - 4);
6448         if (!ea_list) {
6449                 return NT_STATUS_INVALID_PARAMETER;
6450         }
6451
6452         status = set_ea(conn, fsp, smb_fname, ea_list);
6453
6454         return status;
6455 }
6456
6457 /****************************************************************************
6458  Deal with SMB_FILE_FULL_EA_INFORMATION set.
6459 ****************************************************************************/
6460
6461 static NTSTATUS smb_set_file_full_ea_info(connection_struct *conn,
6462                                 const char *pdata,
6463                                 int total_data,
6464                                 files_struct *fsp)
6465 {
6466         struct ea_list *ea_list = NULL;
6467         NTSTATUS status;
6468
6469         if (!fsp) {
6470                 return NT_STATUS_INVALID_HANDLE;
6471         }
6472
6473         if (!lp_ea_support(SNUM(conn))) {
6474                 DEBUG(10, ("smb_set_file_full_ea_info - ea_len = %u but "
6475                         "EA's not supported.\n",
6476                         (unsigned int)total_data));
6477                 return NT_STATUS_EAS_NOT_SUPPORTED;
6478         }
6479
6480         if (total_data < 10) {
6481                 DEBUG(10, ("smb_set_file_full_ea_info - ea_len = %u "
6482                         "too small.\n",
6483                         (unsigned int)total_data));
6484                 return NT_STATUS_INVALID_PARAMETER;
6485         }
6486
6487         ea_list = read_nttrans_ea_list(talloc_tos(),
6488                                 pdata,
6489                                 total_data);
6490
6491         if (!ea_list) {
6492                 return NT_STATUS_INVALID_PARAMETER;
6493         }
6494
6495         status = set_ea(conn, fsp, fsp->fsp_name, ea_list);
6496
6497         DEBUG(10, ("smb_set_file_full_ea_info on file %s returned %s\n",
6498                 smb_fname_str_dbg(fsp->fsp_name),
6499                 nt_errstr(status) ));
6500
6501         return status;
6502 }
6503
6504
6505 /****************************************************************************
6506  Deal with SMB_SET_FILE_DISPOSITION_INFO.
6507 ****************************************************************************/
6508
6509 static NTSTATUS smb_set_file_disposition_info(connection_struct *conn,
6510                                 const char *pdata,
6511                                 int total_data,
6512                                 files_struct *fsp,
6513                                 struct smb_filename *smb_fname)
6514 {
6515         NTSTATUS status = NT_STATUS_OK;
6516         bool delete_on_close;
6517         uint32_t dosmode = 0;
6518
6519         if (total_data < 1) {
6520                 return NT_STATUS_INVALID_PARAMETER;
6521         }
6522
6523         if (fsp == NULL) {
6524                 return NT_STATUS_INVALID_HANDLE;
6525         }
6526
6527         delete_on_close = (CVAL(pdata,0) ? True : False);
6528         dosmode = dos_mode(conn, smb_fname);
6529
6530         DEBUG(10,("smb_set_file_disposition_info: file %s, dosmode = %u, "
6531                 "delete_on_close = %u\n",
6532                 smb_fname_str_dbg(smb_fname),
6533                 (unsigned int)dosmode,
6534                 (unsigned int)delete_on_close ));
6535
6536         if (delete_on_close) {
6537                 status = can_set_delete_on_close(fsp, dosmode);
6538                 if (!NT_STATUS_IS_OK(status)) {
6539                         return status;
6540                 }
6541         }
6542
6543         /* The set is across all open files on this dev/inode pair. */
6544         if (!set_delete_on_close(fsp, delete_on_close,
6545                                  conn->session_info->security_token,
6546                                  conn->session_info->unix_token)) {
6547                 return NT_STATUS_ACCESS_DENIED;
6548         }
6549         return NT_STATUS_OK;
6550 }
6551
6552 /****************************************************************************
6553  Deal with SMB_FILE_POSITION_INFORMATION.
6554 ****************************************************************************/
6555
6556 static NTSTATUS smb_file_position_information(connection_struct *conn,
6557                                 const char *pdata,
6558                                 int total_data,
6559                                 files_struct *fsp)
6560 {
6561         uint64_t position_information;
6562
6563         if (total_data < 8) {
6564                 return NT_STATUS_INVALID_PARAMETER;
6565         }
6566
6567         if (fsp == NULL) {
6568                 /* Ignore on pathname based set. */
6569                 return NT_STATUS_OK;
6570         }
6571
6572         position_information = (uint64_t)IVAL(pdata,0);
6573         position_information |= (((uint64_t)IVAL(pdata,4)) << 32);
6574
6575         DEBUG(10,("smb_file_position_information: Set file position "
6576                   "information for file %s to %.0f\n", fsp_str_dbg(fsp),
6577                   (double)position_information));
6578         fsp->fh->position_information = position_information;
6579         return NT_STATUS_OK;
6580 }
6581
6582 /****************************************************************************
6583  Deal with SMB_FILE_MODE_INFORMATION.
6584 ****************************************************************************/
6585
6586 static NTSTATUS smb_file_mode_information(connection_struct *conn,
6587                                 const char *pdata,
6588                                 int total_data)
6589 {
6590         uint32_t mode;
6591
6592         if (total_data < 4) {
6593                 return NT_STATUS_INVALID_PARAMETER;
6594         }
6595         mode = IVAL(pdata,0);
6596         if (mode != 0 && mode != 2 && mode != 4 && mode != 6) {
6597                 return NT_STATUS_INVALID_PARAMETER;
6598         }
6599         return NT_STATUS_OK;
6600 }
6601
6602 /****************************************************************************
6603  Deal with SMB_SET_FILE_UNIX_LINK (create a UNIX symlink).
6604 ****************************************************************************/
6605
6606 static NTSTATUS smb_set_file_unix_link(connection_struct *conn,
6607                                        struct smb_request *req,
6608                                        const char *pdata,
6609                                        int total_data,
6610                                        const struct smb_filename *new_smb_fname)
6611 {
6612         char *link_target = NULL;
6613         TALLOC_CTX *ctx = talloc_tos();
6614
6615         /* Set a symbolic link. */
6616         /* Don't allow this if follow links is false. */
6617
6618         if (total_data == 0) {
6619                 return NT_STATUS_INVALID_PARAMETER;
6620         }
6621
6622         if (!lp_follow_symlinks(SNUM(conn))) {
6623                 return NT_STATUS_ACCESS_DENIED;
6624         }
6625
6626         srvstr_pull_talloc(ctx, pdata, req->flags2, &link_target, pdata,
6627                     total_data, STR_TERMINATE);
6628
6629         if (!link_target) {
6630                 return NT_STATUS_INVALID_PARAMETER;
6631         }
6632
6633         DEBUG(10,("smb_set_file_unix_link: SMB_SET_FILE_UNIX_LINK doing symlink %s -> %s\n",
6634                         new_smb_fname->base_name, link_target ));
6635
6636         if (SMB_VFS_SYMLINK(conn,link_target,new_smb_fname) != 0) {
6637                 return map_nt_error_from_unix(errno);
6638         }
6639
6640         return NT_STATUS_OK;
6641 }
6642
6643 /****************************************************************************
6644  Deal with SMB_SET_FILE_UNIX_HLINK (create a UNIX hard link).
6645 ****************************************************************************/
6646
6647 static NTSTATUS smb_set_file_unix_hlink(connection_struct *conn,
6648                                         struct smb_request *req,
6649                                         const char *pdata, int total_data,
6650                                         struct smb_filename *smb_fname_new)
6651 {
6652         char *oldname = NULL;
6653         struct smb_filename *smb_fname_old = NULL;
6654         uint32_t ucf_flags = ucf_flags_from_smb_request(req);
6655         TALLOC_CTX *ctx = talloc_tos();
6656         NTSTATUS status = NT_STATUS_OK;
6657
6658         /* Set a hard link. */
6659         if (total_data == 0) {
6660                 return NT_STATUS_INVALID_PARAMETER;
6661         }
6662
6663         if (req->posix_pathnames) {
6664                 srvstr_get_path_posix(ctx,
6665                         pdata,
6666                         req->flags2,
6667                         &oldname,
6668                         pdata,
6669                         total_data,
6670                         STR_TERMINATE,
6671                         &status);
6672         } else {
6673                 srvstr_get_path(ctx,
6674                         pdata,
6675                         req->flags2,
6676                         &oldname,
6677                         pdata,
6678                         total_data,
6679                         STR_TERMINATE,
6680                         &status);
6681         }
6682         if (!NT_STATUS_IS_OK(status)) {
6683                 return status;
6684         }
6685
6686         DEBUG(10,("smb_set_file_unix_hlink: SMB_SET_FILE_UNIX_LINK doing hard link %s -> %s\n",
6687                 smb_fname_str_dbg(smb_fname_new), oldname));
6688
6689         status = filename_convert(ctx,
6690                                 conn,
6691                                 oldname,
6692                                 ucf_flags,
6693                                 NULL,
6694                                 &smb_fname_old);
6695         if (!NT_STATUS_IS_OK(status)) {
6696                 return status;
6697         }
6698
6699         return hardlink_internals(ctx, conn, req, false,
6700                         smb_fname_old, smb_fname_new);
6701 }
6702
6703 /****************************************************************************
6704  Deal with SMB2_FILE_RENAME_INFORMATION_INTERNAL
6705 ****************************************************************************/
6706
6707 static NTSTATUS smb2_file_rename_information(connection_struct *conn,
6708                                             struct smb_request *req,
6709                                             const char *pdata,
6710                                             int total_data,
6711                                             files_struct *fsp,
6712                                             struct smb_filename *smb_fname_src)
6713 {
6714         bool overwrite;
6715         uint32_t len;
6716         char *newname = NULL;
6717         struct smb_filename *smb_fname_dst = NULL;
6718         uint32_t ucf_flags = UCF_SAVE_LCOMP |
6719                 ucf_flags_from_smb_request(req);
6720         NTSTATUS status = NT_STATUS_OK;
6721         TALLOC_CTX *ctx = talloc_tos();
6722
6723         if (!fsp) {
6724                 return NT_STATUS_INVALID_HANDLE;
6725         }
6726
6727         if (total_data < 20) {
6728                 return NT_STATUS_INVALID_PARAMETER;
6729         }
6730
6731         overwrite = (CVAL(pdata,0) ? True : False);
6732         len = IVAL(pdata,16);
6733
6734         if (len > (total_data - 20) || (len == 0)) {
6735                 return NT_STATUS_INVALID_PARAMETER;
6736         }
6737
6738         if (req->posix_pathnames) {
6739                 srvstr_get_path_posix(ctx,
6740                                 pdata,
6741                                 req->flags2,
6742                                 &newname,
6743                                 &pdata[20],
6744                                 len,
6745                                 STR_TERMINATE,
6746                                 &status);
6747         } else {
6748                 srvstr_get_path(ctx,
6749                                 pdata,
6750                                 req->flags2,
6751                                 &newname,
6752                                 &pdata[20],
6753                                 len,
6754                                 STR_TERMINATE,
6755                                 &status);
6756         }
6757         if (!NT_STATUS_IS_OK(status)) {
6758                 return status;
6759         }
6760
6761         DEBUG(10,("smb2_file_rename_information: got name |%s|\n",
6762                                 newname));
6763
6764         status = filename_convert(ctx,
6765                                 conn,
6766                                 newname,
6767                                 ucf_flags,
6768                                 NULL,
6769                                 &smb_fname_dst);
6770         if (!NT_STATUS_IS_OK(status)) {
6771                 return status;
6772         }
6773
6774         if (fsp->base_fsp) {
6775                 /* newname must be a stream name. */
6776                 if (newname[0] != ':') {
6777                         return NT_STATUS_NOT_SUPPORTED;
6778                 }
6779
6780                 /* Create an smb_fname to call rename_internals_fsp() with. */
6781                 smb_fname_dst = synthetic_smb_fname(talloc_tos(),
6782                                         fsp->base_fsp->fsp_name->base_name,
6783                                         newname,
6784                                         NULL,
6785                                         fsp->base_fsp->fsp_name->flags);
6786                 if (smb_fname_dst == NULL) {
6787                         status = NT_STATUS_NO_MEMORY;
6788                         goto out;
6789                 }
6790
6791                 /*
6792                  * Set the original last component, since
6793                  * rename_internals_fsp() requires it.
6794                  */
6795                 smb_fname_dst->original_lcomp = talloc_strdup(smb_fname_dst,
6796                                                               newname);
6797                 if (smb_fname_dst->original_lcomp == NULL) {
6798                         status = NT_STATUS_NO_MEMORY;
6799                         goto out;
6800                 }
6801
6802         }
6803
6804         DEBUG(10,("smb2_file_rename_information: "
6805                   "SMB_FILE_RENAME_INFORMATION (%s) %s -> %s\n",
6806                   fsp_fnum_dbg(fsp), fsp_str_dbg(fsp),
6807                   smb_fname_str_dbg(smb_fname_dst)));
6808         status = rename_internals_fsp(conn, fsp, smb_fname_dst,
6809                                 (FILE_ATTRIBUTE_HIDDEN|FILE_ATTRIBUTE_SYSTEM),
6810                                 overwrite);
6811
6812  out:
6813         TALLOC_FREE(smb_fname_dst);
6814         return status;
6815 }
6816
6817 static NTSTATUS smb_file_link_information(connection_struct *conn,
6818                                             struct smb_request *req,
6819                                             const char *pdata,
6820                                             int total_data,
6821                                             files_struct *fsp,
6822                                             struct smb_filename *smb_fname_src)
6823 {
6824         bool overwrite;
6825         uint32_t len;
6826         char *newname = NULL;
6827         struct smb_filename *smb_fname_dst = NULL;
6828         NTSTATUS status = NT_STATUS_OK;
6829         uint32_t ucf_flags = UCF_SAVE_LCOMP |
6830                 ucf_flags_from_smb_request(req);
6831         TALLOC_CTX *ctx = talloc_tos();
6832
6833         if (!fsp) {
6834                 return NT_STATUS_INVALID_HANDLE;
6835         }
6836
6837         if (total_data < 20) {
6838                 return NT_STATUS_INVALID_PARAMETER;
6839         }
6840
6841         overwrite = (CVAL(pdata,0) ? true : false);
6842         len = IVAL(pdata,16);
6843
6844         if (len > (total_data - 20) || (len == 0)) {
6845                 return NT_STATUS_INVALID_PARAMETER;
6846         }
6847
6848         if (req->posix_pathnames) {
6849                 srvstr_get_path_posix(ctx,
6850                                 pdata,
6851                                 req->flags2,
6852                                 &newname,
6853                                 &pdata[20],
6854                                 len,
6855                                 STR_TERMINATE,
6856                                 &status);
6857         } else {
6858                 srvstr_get_path(ctx,
6859                                 pdata,
6860                                 req->flags2,
6861                                 &newname,
6862                                 &pdata[20],
6863                                 len,
6864                                 STR_TERMINATE,
6865                                 &status);
6866         }
6867         if (!NT_STATUS_IS_OK(status)) {
6868                 return status;
6869         }
6870
6871         DEBUG(10,("smb_file_link_information: got name |%s|\n",
6872                                 newname));
6873
6874         status = filename_convert(ctx,
6875                                 conn,
6876                                 newname,
6877                                 ucf_flags,
6878                                 NULL,
6879                                 &smb_fname_dst);
6880         if (!NT_STATUS_IS_OK(status)) {
6881                 return status;
6882         }
6883
6884         if (fsp->base_fsp) {
6885                 /* No stream names. */
6886                 return NT_STATUS_NOT_SUPPORTED;
6887         }
6888
6889         DEBUG(10,("smb_file_link_information: "
6890                   "SMB_FILE_LINK_INFORMATION (%s) %s -> %s\n",
6891                   fsp_fnum_dbg(fsp), fsp_str_dbg(fsp),
6892                   smb_fname_str_dbg(smb_fname_dst)));
6893         status = hardlink_internals(ctx,
6894                                 conn,
6895                                 req,
6896                                 overwrite,
6897                                 fsp->fsp_name,
6898                                 smb_fname_dst);
6899
6900         TALLOC_FREE(smb_fname_dst);
6901         return status;
6902 }
6903
6904 /****************************************************************************
6905  Deal with SMB_FILE_RENAME_INFORMATION.
6906 ****************************************************************************/
6907
6908 static NTSTATUS smb_file_rename_information(connection_struct *conn,
6909                                             struct smb_request *req,
6910                                             const char *pdata,
6911                                             int total_data,
6912                                             files_struct *fsp,
6913                                             struct smb_filename *smb_fname_src)
6914 {
6915         bool overwrite;
6916         uint32_t root_fid;
6917         uint32_t len;
6918         char *newname = NULL;
6919         struct smb_filename *smb_fname_dst = NULL;
6920         bool dest_has_wcard = False;
6921         NTSTATUS status = NT_STATUS_OK;
6922         char *p;
6923         TALLOC_CTX *ctx = talloc_tos();
6924
6925         if (total_data < 13) {
6926                 return NT_STATUS_INVALID_PARAMETER;
6927         }
6928
6929         overwrite = (CVAL(pdata,0) ? True : False);
6930         root_fid = IVAL(pdata,4);
6931         len = IVAL(pdata,8);
6932
6933         if (len > (total_data - 12) || (len == 0) || (root_fid != 0)) {
6934                 return NT_STATUS_INVALID_PARAMETER;
6935         }
6936
6937         if (req->posix_pathnames) {
6938                 srvstr_get_path_wcard_posix(ctx,
6939                                 pdata,
6940                                 req->flags2,
6941                                 &newname,
6942                                 &pdata[12],
6943                                 len,
6944                                 0,
6945                                 &status,
6946                                 &dest_has_wcard);
6947         } else {
6948                 srvstr_get_path_wcard(ctx,
6949                                 pdata,
6950                                 req->flags2,
6951                                 &newname,
6952                                 &pdata[12],
6953                                 len,
6954                                 0,
6955                                 &status,
6956                                 &dest_has_wcard);
6957         }
6958         if (!NT_STATUS_IS_OK(status)) {
6959                 return status;
6960         }
6961
6962         DEBUG(10,("smb_file_rename_information: got name |%s|\n",
6963                                 newname));
6964
6965         if (req->flags2 & FLAGS2_DFS_PATHNAMES) {
6966                 status = resolve_dfspath_wcard(ctx, conn,
6967                                        newname,
6968                                        UCF_COND_ALLOW_WCARD_LCOMP,
6969                                        !conn->sconn->using_smb2,
6970                                        &newname,
6971                                        &dest_has_wcard);
6972                 if (!NT_STATUS_IS_OK(status)) {
6973                         return status;
6974                 }
6975         }
6976
6977         /* Check the new name has no '/' characters. */
6978         if (strchr_m(newname, '/')) {
6979                 return NT_STATUS_NOT_SUPPORTED;
6980         }
6981
6982         if (fsp && fsp->base_fsp) {
6983                 /* newname must be a stream name. */
6984                 if (newname[0] != ':') {
6985                         return NT_STATUS_NOT_SUPPORTED;
6986                 }
6987
6988                 /* Create an smb_fname to call rename_internals_fsp() with. */
6989                 smb_fname_dst = synthetic_smb_fname(talloc_tos(),
6990                                         fsp->base_fsp->fsp_name->base_name,
6991                                         newname,
6992                                         NULL,
6993                                         fsp->base_fsp->fsp_name->flags);
6994                 if (smb_fname_dst == NULL) {
6995                         status = NT_STATUS_NO_MEMORY;
6996                         goto out;
6997                 }
6998
6999                 /*
7000                  * Set the original last component, since
7001                  * rename_internals_fsp() requires it.
7002                  */
7003                 smb_fname_dst->original_lcomp = talloc_strdup(smb_fname_dst,
7004                                                               newname);
7005                 if (smb_fname_dst->original_lcomp == NULL) {
7006                         status = NT_STATUS_NO_MEMORY;
7007                         goto out;
7008                 }
7009
7010         } else {
7011                 /*
7012                  * Build up an smb_fname_dst based on the filename passed in.
7013                  * We basically just strip off the last component, and put on
7014                  * the newname instead.
7015                  */
7016                 char *base_name = NULL;
7017                 uint32_t ucf_flags = UCF_SAVE_LCOMP |
7018                         ucf_flags_from_smb_request(req);
7019
7020                 if (dest_has_wcard) {
7021                         ucf_flags |= UCF_ALWAYS_ALLOW_WCARD_LCOMP;
7022                 }
7023
7024                 /* newname must *not* be a stream name. */
7025                 if (newname[0] == ':') {
7026                         return NT_STATUS_NOT_SUPPORTED;
7027                 }
7028
7029                 /*
7030                  * Strip off the last component (filename) of the path passed
7031                  * in.
7032                  */
7033                 base_name = talloc_strdup(ctx, smb_fname_src->base_name);
7034                 if (!base_name) {
7035                         return NT_STATUS_NO_MEMORY;
7036                 }
7037                 p = strrchr_m(base_name, '/');
7038                 if (p) {
7039                         p[1] = '\0';
7040                 } else {
7041                         base_name = talloc_strdup(ctx, "");
7042                         if (!base_name) {
7043                                 return NT_STATUS_NO_MEMORY;
7044                         }
7045                 }
7046                 /* Append the new name. */
7047                 base_name = talloc_asprintf_append(base_name,
7048                                 "%s",
7049                                 newname);
7050                 if (!base_name) {
7051                         return NT_STATUS_NO_MEMORY;
7052                 }
7053
7054                 status = unix_convert(ctx, conn, base_name, &smb_fname_dst,
7055                                         ucf_flags);
7056
7057                 /* If an error we expect this to be
7058                  * NT_STATUS_OBJECT_PATH_NOT_FOUND */
7059
7060                 if (!NT_STATUS_IS_OK(status)) {
7061                         if(!NT_STATUS_EQUAL(NT_STATUS_OBJECT_PATH_NOT_FOUND,
7062                                             status)) {
7063                                 goto out;
7064                         }
7065                         /* Create an smb_fname to call rename_internals_fsp() */
7066                         smb_fname_dst = synthetic_smb_fname(ctx,
7067                                                 base_name,
7068                                                 NULL,
7069                                                 NULL,
7070                                                 smb_fname_src->flags);
7071                         if (smb_fname_dst == NULL) {
7072                                 status = NT_STATUS_NO_MEMORY;
7073                                 goto out;
7074                         }
7075                 }
7076         }
7077
7078         if (fsp) {
7079                 DEBUG(10,("smb_file_rename_information: "
7080                           "SMB_FILE_RENAME_INFORMATION (%s) %s -> %s\n",
7081                           fsp_fnum_dbg(fsp), fsp_str_dbg(fsp),
7082                           smb_fname_str_dbg(smb_fname_dst)));
7083                 status = rename_internals_fsp(conn, fsp, smb_fname_dst, 0,
7084                                               overwrite);
7085         } else {
7086                 DEBUG(10,("smb_file_rename_information: "
7087                           "SMB_FILE_RENAME_INFORMATION %s -> %s\n",
7088                           smb_fname_str_dbg(smb_fname_src),
7089                           smb_fname_str_dbg(smb_fname_dst)));
7090                 status = rename_internals(ctx, conn, req, smb_fname_src,
7091                                           smb_fname_dst, 0, overwrite, false,
7092                                           dest_has_wcard,
7093                                           FILE_WRITE_ATTRIBUTES);
7094         }
7095  out:
7096         TALLOC_FREE(smb_fname_dst);
7097         return status;
7098 }
7099
7100 /****************************************************************************
7101  Deal with SMB_SET_POSIX_ACL.
7102 ****************************************************************************/
7103
7104 #if defined(HAVE_POSIX_ACLS)
7105 static NTSTATUS smb_set_posix_acl(connection_struct *conn,
7106                                 const char *pdata,
7107                                 int total_data,
7108                                 files_struct *fsp,
7109                                 const struct smb_filename *smb_fname)
7110 {
7111         uint16_t posix_acl_version;
7112         uint16_t num_file_acls;
7113         uint16_t num_def_acls;
7114         bool valid_file_acls = True;
7115         bool valid_def_acls = True;
7116         NTSTATUS status;
7117
7118         if (total_data < SMB_POSIX_ACL_HEADER_SIZE) {
7119                 return NT_STATUS_INVALID_PARAMETER;
7120         }
7121         posix_acl_version = SVAL(pdata,0);
7122         num_file_acls = SVAL(pdata,2);
7123         num_def_acls = SVAL(pdata,4);
7124
7125         if (num_file_acls == SMB_POSIX_IGNORE_ACE_ENTRIES) {
7126                 valid_file_acls = False;
7127                 num_file_acls = 0;
7128         }
7129
7130         if (num_def_acls == SMB_POSIX_IGNORE_ACE_ENTRIES) {
7131                 valid_def_acls = False;
7132                 num_def_acls = 0;
7133         }
7134
7135         if (posix_acl_version != SMB_POSIX_ACL_VERSION) {
7136                 return NT_STATUS_INVALID_PARAMETER;
7137         }
7138
7139         if (total_data < SMB_POSIX_ACL_HEADER_SIZE +
7140                         (num_file_acls+num_def_acls)*SMB_POSIX_ACL_ENTRY_SIZE) {
7141                 return NT_STATUS_INVALID_PARAMETER;
7142         }
7143
7144         status = refuse_symlink(conn, fsp, smb_fname);
7145         if (!NT_STATUS_IS_OK(status)) {
7146                 return status;
7147         }
7148
7149         DEBUG(10,("smb_set_posix_acl: file %s num_file_acls = %u, num_def_acls = %u\n",
7150                 smb_fname ? smb_fname_str_dbg(smb_fname) : fsp_str_dbg(fsp),
7151                 (unsigned int)num_file_acls,
7152                 (unsigned int)num_def_acls));
7153
7154         if (valid_file_acls && !set_unix_posix_acl(conn, fsp,
7155                 smb_fname, num_file_acls,
7156                 pdata + SMB_POSIX_ACL_HEADER_SIZE)) {
7157                 return map_nt_error_from_unix(errno);
7158         }
7159
7160         if (valid_def_acls && !set_unix_posix_default_acl(conn,
7161                 smb_fname, num_def_acls,
7162                 pdata + SMB_POSIX_ACL_HEADER_SIZE +
7163                 (num_file_acls*SMB_POSIX_ACL_ENTRY_SIZE))) {
7164                 return map_nt_error_from_unix(errno);
7165         }
7166         return NT_STATUS_OK;
7167 }
7168 #endif
7169
7170 /****************************************************************************
7171  Deal with SMB_SET_POSIX_LOCK.
7172 ****************************************************************************/
7173
7174 static NTSTATUS smb_set_posix_lock(connection_struct *conn,
7175                                 struct smb_request *req,
7176                                 const char *pdata,
7177                                 int total_data,
7178                                 files_struct *fsp)
7179 {
7180         uint64_t count;
7181         uint64_t offset;
7182         uint64_t smblctx;
7183         bool blocking_lock = False;
7184         enum brl_type lock_type;
7185
7186         NTSTATUS status = NT_STATUS_OK;
7187
7188         if (fsp == NULL || fsp->fh->fd == -1) {
7189                 return NT_STATUS_INVALID_HANDLE;
7190         }
7191
7192         if (total_data != POSIX_LOCK_DATA_SIZE) {
7193                 return NT_STATUS_INVALID_PARAMETER;
7194         }
7195
7196         switch (SVAL(pdata, POSIX_LOCK_TYPE_OFFSET)) {
7197                 case POSIX_LOCK_TYPE_READ:
7198                         lock_type = READ_LOCK;
7199                         break;
7200                 case POSIX_LOCK_TYPE_WRITE:
7201                         /* Return the right POSIX-mappable error code for files opened read-only. */
7202                         if (!fsp->can_write) {
7203                                 return NT_STATUS_INVALID_HANDLE;
7204                         }
7205                         lock_type = WRITE_LOCK;
7206                         break;
7207                 case POSIX_LOCK_TYPE_UNLOCK:
7208                         lock_type = UNLOCK_LOCK;
7209                         break;
7210                 default:
7211                         return NT_STATUS_INVALID_PARAMETER;
7212         }
7213
7214         if (SVAL(pdata,POSIX_LOCK_FLAGS_OFFSET) == POSIX_LOCK_FLAG_NOWAIT) {
7215                 blocking_lock = False;
7216         } else if (SVAL(pdata,POSIX_LOCK_FLAGS_OFFSET) == POSIX_LOCK_FLAG_WAIT) {
7217                 blocking_lock = True;
7218         } else {
7219                 return NT_STATUS_INVALID_PARAMETER;
7220         }
7221
7222         if (!lp_blocking_locks(SNUM(conn))) {
7223                 blocking_lock = False;
7224         }
7225
7226         smblctx = (uint64_t)IVAL(pdata, POSIX_LOCK_PID_OFFSET);
7227         offset = (((uint64_t) IVAL(pdata,(POSIX_LOCK_START_OFFSET+4))) << 32) |
7228                         ((uint64_t) IVAL(pdata,POSIX_LOCK_START_OFFSET));
7229         count = (((uint64_t) IVAL(pdata,(POSIX_LOCK_LEN_OFFSET+4))) << 32) |
7230                         ((uint64_t) IVAL(pdata,POSIX_LOCK_LEN_OFFSET));
7231
7232         DEBUG(10,("smb_set_posix_lock: file %s, lock_type = %u,"
7233                         "smblctx = %llu, count = %.0f, offset = %.0f\n",
7234                 fsp_str_dbg(fsp),
7235                 (unsigned int)lock_type,
7236                 (unsigned long long)smblctx,
7237                 (double)count,
7238                 (double)offset ));
7239
7240         if (lock_type == UNLOCK_LOCK) {
7241                 status = do_unlock(req->sconn->msg_ctx,
7242                                 fsp,
7243                                 smblctx,
7244                                 count,
7245                                 offset,
7246                                 POSIX_LOCK);
7247         } else {
7248                 uint64_t block_smblctx;
7249
7250                 struct byte_range_lock *br_lck = do_lock(req->sconn->msg_ctx,
7251                                                         fsp,
7252                                                         smblctx,
7253                                                         count,
7254                                                         offset,
7255                                                         lock_type,
7256                                                         POSIX_LOCK,
7257                                                         blocking_lock,
7258                                                         &status,
7259                                                         &block_smblctx);
7260
7261                 if (br_lck && blocking_lock && ERROR_WAS_LOCK_DENIED(status)) {
7262                         /*
7263                          * A blocking lock was requested. Package up
7264                          * this smb into a queued request and push it
7265                          * onto the blocking lock queue.
7266                          */
7267                         if(push_blocking_lock_request(br_lck,
7268                                                 req,
7269                                                 fsp,
7270                                                 -1, /* infinite timeout. */
7271                                                 0,
7272                                                 smblctx,
7273                                                 lock_type,
7274                                                 POSIX_LOCK,
7275                                                 offset,
7276                                                 count,
7277                                                 block_smblctx)) {
7278                                 TALLOC_FREE(br_lck);
7279                                 return status;
7280                         }
7281                 }
7282                 TALLOC_FREE(br_lck);
7283         }
7284
7285         return status;
7286 }
7287
7288 /****************************************************************************
7289  Deal with SMB_SET_FILE_BASIC_INFO.
7290 ****************************************************************************/
7291
7292 static NTSTATUS smb_set_file_basic_info(connection_struct *conn,
7293                                         const char *pdata,
7294                                         int total_data,
7295                                         files_struct *fsp,
7296                                         const struct smb_filename *smb_fname)
7297 {
7298         /* Patch to do this correctly from Paul Eggert <eggert@twinsun.com>. */
7299         struct smb_file_time ft;
7300         uint32_t dosmode = 0;
7301         NTSTATUS status = NT_STATUS_OK;
7302
7303         ZERO_STRUCT(ft);
7304
7305         if (total_data < 36) {
7306                 return NT_STATUS_INVALID_PARAMETER;
7307         }
7308
7309         status = check_access(conn, fsp, smb_fname, FILE_WRITE_ATTRIBUTES);
7310         if (!NT_STATUS_IS_OK(status)) {
7311                 return status;
7312         }
7313
7314         /* Set the attributes */
7315         dosmode = IVAL(pdata,32);
7316         status = smb_set_file_dosmode(conn, smb_fname, dosmode);
7317         if (!NT_STATUS_IS_OK(status)) {
7318                 return status;
7319         }
7320
7321         /* create time */
7322         ft.create_time = interpret_long_date(pdata);
7323
7324         /* access time */
7325         ft.atime = interpret_long_date(pdata+8);
7326
7327         /* write time. */
7328         ft.mtime = interpret_long_date(pdata+16);
7329
7330         /* change time. */
7331         ft.ctime = interpret_long_date(pdata+24);
7332
7333         DEBUG(10, ("smb_set_file_basic_info: file %s\n",
7334                    smb_fname_str_dbg(smb_fname)));
7335
7336         return smb_set_file_time(conn, fsp, smb_fname, &ft,
7337                                  true);
7338 }
7339
7340 /****************************************************************************
7341  Deal with SMB_INFO_STANDARD.
7342 ****************************************************************************/
7343
7344 static NTSTATUS smb_set_info_standard(connection_struct *conn,
7345                                         const char *pdata,
7346                                         int total_data,
7347                                         files_struct *fsp,
7348                                         const struct smb_filename *smb_fname)
7349 {
7350         NTSTATUS status;
7351         struct smb_file_time ft;
7352
7353         ZERO_STRUCT(ft);
7354
7355         if (total_data < 12) {
7356                 return NT_STATUS_INVALID_PARAMETER;
7357         }
7358
7359         /* create time */
7360         ft.create_time = convert_time_t_to_timespec(srv_make_unix_date2(pdata));
7361         /* access time */
7362         ft.atime = convert_time_t_to_timespec(srv_make_unix_date2(pdata+4));
7363         /* write time */
7364         ft.mtime = convert_time_t_to_timespec(srv_make_unix_date2(pdata+8));
7365
7366         DEBUG(10,("smb_set_info_standard: file %s\n",
7367                 smb_fname_str_dbg(smb_fname)));
7368
7369         status = check_access(conn, fsp, smb_fname, FILE_WRITE_ATTRIBUTES);
7370         if (!NT_STATUS_IS_OK(status)) {
7371                 return status;
7372         }
7373
7374         return smb_set_file_time(conn,
7375                                 fsp,
7376                                 smb_fname,
7377                                 &ft,
7378                                 true);
7379 }
7380
7381 /****************************************************************************
7382  Deal with SMB_SET_FILE_ALLOCATION_INFO.
7383 ****************************************************************************/
7384
7385 static NTSTATUS smb_set_file_allocation_info(connection_struct *conn,
7386                                              struct smb_request *req,
7387                                         const char *pdata,
7388                                         int total_data,
7389                                         files_struct *fsp,
7390                                         struct smb_filename *smb_fname)
7391 {
7392         uint64_t allocation_size = 0;
7393         NTSTATUS status = NT_STATUS_OK;
7394         files_struct *new_fsp = NULL;
7395
7396         if (!VALID_STAT(smb_fname->st)) {
7397                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
7398         }
7399
7400         if (total_data < 8) {
7401                 return NT_STATUS_INVALID_PARAMETER;
7402         }
7403
7404         allocation_size = (uint64_t)IVAL(pdata,0);
7405         allocation_size |= (((uint64_t)IVAL(pdata,4)) << 32);
7406         DEBUG(10,("smb_set_file_allocation_info: Set file allocation info for "
7407                   "file %s to %.0f\n", smb_fname_str_dbg(smb_fname),
7408                   (double)allocation_size));
7409
7410         if (allocation_size) {
7411                 allocation_size = smb_roundup(conn, allocation_size);
7412         }
7413
7414         DEBUG(10,("smb_set_file_allocation_info: file %s : setting new "
7415                   "allocation size to %.0f\n", smb_fname_str_dbg(smb_fname),
7416                   (double)allocation_size));
7417
7418         if (fsp && fsp->fh->fd != -1) {
7419                 /* Open file handle. */
7420                 if (!(fsp->access_mask & FILE_WRITE_DATA)) {
7421                         return NT_STATUS_ACCESS_DENIED;
7422                 }
7423
7424                 /* Only change if needed. */
7425                 if (allocation_size != get_file_size_stat(&smb_fname->st)) {
7426                         if (vfs_allocate_file_space(fsp, allocation_size) == -1) {
7427                                 return map_nt_error_from_unix(errno);
7428                         }
7429                 }
7430                 /* But always update the time. */
7431                 /*
7432                  * This is equivalent to a write. Ensure it's seen immediately
7433                  * if there are no pending writes.
7434                  */
7435                 trigger_write_time_update_immediate(fsp);
7436                 return NT_STATUS_OK;
7437         }
7438
7439         /* Pathname or stat or directory file. */
7440         status = SMB_VFS_CREATE_FILE(
7441                 conn,                                   /* conn */
7442                 req,                                    /* req */
7443                 0,                                      /* root_dir_fid */
7444                 smb_fname,                              /* fname */
7445                 FILE_WRITE_DATA,                        /* access_mask */
7446                 (FILE_SHARE_READ | FILE_SHARE_WRITE |   /* share_access */
7447                     FILE_SHARE_DELETE),
7448                 FILE_OPEN,                              /* create_disposition*/
7449                 0,                                      /* create_options */
7450                 FILE_ATTRIBUTE_NORMAL,                  /* file_attributes */
7451                 0,                                      /* oplock_request */
7452                 NULL,                                   /* lease */
7453                 0,                                      /* allocation_size */
7454                 0,                                      /* private_flags */
7455                 NULL,                                   /* sd */
7456                 NULL,                                   /* ea_list */
7457                 &new_fsp,                               /* result */
7458                 NULL,                                   /* pinfo */
7459                 NULL, NULL);                            /* create context */
7460
7461         if (!NT_STATUS_IS_OK(status)) {
7462                 /* NB. We check for open_was_deferred in the caller. */
7463                 return status;
7464         }
7465
7466         /* Only change if needed. */
7467         if (allocation_size != get_file_size_stat(&smb_fname->st)) {
7468                 if (vfs_allocate_file_space(new_fsp, allocation_size) == -1) {
7469                         status = map_nt_error_from_unix(errno);
7470                         close_file(req, new_fsp, NORMAL_CLOSE);
7471                         return status;
7472                 }
7473         }
7474
7475         /* Changing the allocation size should set the last mod time. */
7476         /*
7477          * This is equivalent to a write. Ensure it's seen immediately
7478          * if there are no pending writes.
7479          */
7480         trigger_write_time_update_immediate(new_fsp);
7481         close_file(req, new_fsp, NORMAL_CLOSE);
7482         return NT_STATUS_OK;
7483 }
7484
7485 /****************************************************************************
7486  Deal with SMB_SET_FILE_END_OF_FILE_INFO.
7487 ****************************************************************************/
7488
7489 static NTSTATUS smb_set_file_end_of_file_info(connection_struct *conn,
7490                                               struct smb_request *req,
7491                                         const char *pdata,
7492                                         int total_data,
7493                                         files_struct *fsp,
7494                                         const struct smb_filename *smb_fname,
7495                                         bool fail_after_createfile)
7496 {
7497         off_t size;
7498
7499         if (total_data < 8) {
7500                 return NT_STATUS_INVALID_PARAMETER;
7501         }
7502
7503         size = IVAL(pdata,0);
7504         size |= (((off_t)IVAL(pdata,4)) << 32);
7505         DEBUG(10,("smb_set_file_end_of_file_info: Set end of file info for "
7506                   "file %s to %.0f\n", smb_fname_str_dbg(smb_fname),
7507                   (double)size));
7508
7509         return smb_set_file_size(conn, req,
7510                                 fsp,
7511                                 smb_fname,
7512                                 &smb_fname->st,
7513                                 size,
7514                                 fail_after_createfile);
7515 }
7516
7517 /****************************************************************************
7518  Allow a UNIX info mknod.
7519 ****************************************************************************/
7520
7521 static NTSTATUS smb_unix_mknod(connection_struct *conn,
7522                                         const char *pdata,
7523                                         int total_data,
7524                                         const struct smb_filename *smb_fname)
7525 {
7526         uint32_t file_type = IVAL(pdata,56);
7527 #if defined(HAVE_MAKEDEV)
7528         uint32_t dev_major = IVAL(pdata,60);
7529         uint32_t dev_minor = IVAL(pdata,68);
7530 #endif
7531         SMB_DEV_T dev = (SMB_DEV_T)0;
7532         uint32_t raw_unixmode = IVAL(pdata,84);
7533         NTSTATUS status;
7534         mode_t unixmode;
7535
7536         if (total_data < 100) {
7537                 return NT_STATUS_INVALID_PARAMETER;
7538         }
7539
7540         status = unix_perms_from_wire(conn, &smb_fname->st, raw_unixmode,
7541                                       PERM_NEW_FILE, &unixmode);
7542         if (!NT_STATUS_IS_OK(status)) {
7543                 return status;
7544         }
7545
7546 #if defined(HAVE_MAKEDEV)
7547         dev = makedev(dev_major, dev_minor);
7548 #endif
7549
7550         switch (file_type) {
7551 #if defined(S_IFIFO)
7552                 case UNIX_TYPE_FIFO:
7553                         unixmode |= S_IFIFO;
7554                         break;
7555 #endif
7556 #if defined(S_IFSOCK)
7557                 case UNIX_TYPE_SOCKET:
7558                         unixmode |= S_IFSOCK;
7559                         break;
7560 #endif
7561 #if defined(S_IFCHR)
7562                 case UNIX_TYPE_CHARDEV:
7563                         unixmode |= S_IFCHR;
7564                         break;
7565 #endif
7566 #if defined(S_IFBLK)
7567                 case UNIX_TYPE_BLKDEV:
7568                         unixmode |= S_IFBLK;
7569                         break;
7570 #endif
7571                 default:
7572                         return NT_STATUS_INVALID_PARAMETER;
7573         }
7574
7575         DEBUG(10,("smb_unix_mknod: SMB_SET_FILE_UNIX_BASIC doing mknod dev "
7576                   "%.0f mode 0%o for file %s\n", (double)dev,
7577                   (unsigned int)unixmode, smb_fname_str_dbg(smb_fname)));
7578
7579         /* Ok - do the mknod. */
7580         if (SMB_VFS_MKNOD(conn, smb_fname, unixmode, dev) != 0) {
7581                 return map_nt_error_from_unix(errno);
7582         }
7583
7584         /* If any of the other "set" calls fail we
7585          * don't want to end up with a half-constructed mknod.
7586          */
7587
7588         if (lp_inherit_permissions(SNUM(conn))) {
7589                 char *parent;
7590                 if (!parent_dirname(talloc_tos(), smb_fname->base_name,
7591                                     &parent, NULL)) {
7592                         return NT_STATUS_NO_MEMORY;
7593                 }
7594                 inherit_access_posix_acl(conn, parent, smb_fname,
7595                                          unixmode);
7596                 TALLOC_FREE(parent);
7597         }
7598
7599         return NT_STATUS_OK;
7600 }
7601
7602 /****************************************************************************
7603  Deal with SMB_SET_FILE_UNIX_BASIC.
7604 ****************************************************************************/
7605
7606 static NTSTATUS smb_set_file_unix_basic(connection_struct *conn,
7607                                         struct smb_request *req,
7608                                         const char *pdata,
7609                                         int total_data,
7610                                         files_struct *fsp,
7611                                         const struct smb_filename *smb_fname)
7612 {
7613         struct smb_file_time ft;
7614         uint32_t raw_unixmode;
7615         mode_t unixmode;
7616         off_t size = 0;
7617         uid_t set_owner = (uid_t)SMB_UID_NO_CHANGE;
7618         gid_t set_grp = (uid_t)SMB_GID_NO_CHANGE;
7619         NTSTATUS status = NT_STATUS_OK;
7620         bool delete_on_fail = False;
7621         enum perm_type ptype;
7622         files_struct *all_fsps = NULL;
7623         bool modify_mtime = true;
7624         struct file_id id;
7625         struct smb_filename *smb_fname_tmp = NULL;
7626         SMB_STRUCT_STAT sbuf;
7627
7628         ZERO_STRUCT(ft);
7629
7630         if (total_data < 100) {
7631                 return NT_STATUS_INVALID_PARAMETER;
7632         }
7633
7634         if(IVAL(pdata, 0) != SMB_SIZE_NO_CHANGE_LO &&
7635            IVAL(pdata, 4) != SMB_SIZE_NO_CHANGE_HI) {
7636                 size=IVAL(pdata,0); /* first 8 Bytes are size */
7637                 size |= (((off_t)IVAL(pdata,4)) << 32);
7638         }
7639
7640         ft.atime = interpret_long_date(pdata+24); /* access_time */
7641         ft.mtime = interpret_long_date(pdata+32); /* modification_time */
7642         set_owner = (uid_t)IVAL(pdata,40);
7643         set_grp = (gid_t)IVAL(pdata,48);
7644         raw_unixmode = IVAL(pdata,84);
7645
7646         if (VALID_STAT(smb_fname->st)) {
7647                 if (S_ISDIR(smb_fname->st.st_ex_mode)) {
7648                         ptype = PERM_EXISTING_DIR;
7649                 } else {
7650                         ptype = PERM_EXISTING_FILE;
7651                 }
7652         } else {
7653                 ptype = PERM_NEW_FILE;
7654         }
7655
7656         status = unix_perms_from_wire(conn, &smb_fname->st, raw_unixmode,
7657                                       ptype, &unixmode);
7658         if (!NT_STATUS_IS_OK(status)) {
7659                 return status;
7660         }
7661
7662         DEBUG(10,("smb_set_file_unix_basic: SMB_SET_FILE_UNIX_BASIC: name = "
7663                   "%s size = %.0f, uid = %u, gid = %u, raw perms = 0%o\n",
7664                   smb_fname_str_dbg(smb_fname), (double)size,
7665                   (unsigned int)set_owner, (unsigned int)set_grp,
7666                   (int)raw_unixmode));
7667
7668         sbuf = smb_fname->st;
7669
7670         if (!VALID_STAT(sbuf)) {
7671                 /*
7672                  * The only valid use of this is to create character and block
7673                  * devices, and named pipes. This is deprecated (IMHO) and
7674                  * a new info level should be used for mknod. JRA.
7675                  */
7676
7677                 status = smb_unix_mknod(conn,
7678                                         pdata,
7679                                         total_data,
7680                                         smb_fname);
7681                 if (!NT_STATUS_IS_OK(status)) {
7682                         return status;
7683                 }
7684
7685                 smb_fname_tmp = cp_smb_filename(talloc_tos(), smb_fname);
7686                 if (smb_fname_tmp == NULL) {
7687                         return NT_STATUS_NO_MEMORY;
7688                 }
7689
7690                 if (SMB_VFS_STAT(conn, smb_fname_tmp) != 0) {
7691                         status = map_nt_error_from_unix(errno);
7692                         TALLOC_FREE(smb_fname_tmp);
7693                         SMB_VFS_UNLINK(conn, smb_fname);
7694                         return status;
7695                 }
7696
7697                 sbuf = smb_fname_tmp->st;
7698                 smb_fname = smb_fname_tmp;
7699
7700                 /* Ensure we don't try and change anything else. */
7701                 raw_unixmode = SMB_MODE_NO_CHANGE;
7702                 size = get_file_size_stat(&sbuf);
7703                 ft.atime = sbuf.st_ex_atime;
7704                 ft.mtime = sbuf.st_ex_mtime;
7705                 /*
7706                  * We continue here as we might want to change the
7707                  * owner uid/gid.
7708                  */
7709                 delete_on_fail = True;
7710         }
7711
7712 #if 1
7713         /* Horrible backwards compatibility hack as an old server bug
7714          * allowed a CIFS client bug to remain unnoticed :-(. JRA.
7715          * */
7716
7717         if (!size) {
7718                 size = get_file_size_stat(&sbuf);
7719         }
7720 #endif
7721
7722         /*
7723          * Deal with the UNIX specific mode set.
7724          */
7725
7726         if (raw_unixmode != SMB_MODE_NO_CHANGE) {
7727                 int ret;
7728
7729                 DEBUG(10,("smb_set_file_unix_basic: SMB_SET_FILE_UNIX_BASIC "
7730                           "setting mode 0%o for file %s\n",
7731                           (unsigned int)unixmode,
7732                           smb_fname_str_dbg(smb_fname)));
7733                 if (fsp && fsp->fh->fd != -1) {
7734                         ret = SMB_VFS_FCHMOD(fsp, unixmode);
7735                 } else {
7736                         ret = SMB_VFS_CHMOD(conn, smb_fname, unixmode);
7737                 }
7738                 if (ret != 0) {
7739                         return map_nt_error_from_unix(errno);
7740                 }
7741         }
7742
7743         /*
7744          * Deal with the UNIX specific uid set.
7745          */
7746
7747         if ((set_owner != (uid_t)SMB_UID_NO_CHANGE) &&
7748             (sbuf.st_ex_uid != set_owner)) {
7749                 int ret;
7750
7751                 DEBUG(10,("smb_set_file_unix_basic: SMB_SET_FILE_UNIX_BASIC "
7752                           "changing owner %u for path %s\n",
7753                           (unsigned int)set_owner,
7754                           smb_fname_str_dbg(smb_fname)));
7755
7756                 if (fsp && fsp->fh->fd != -1) {
7757                         ret = SMB_VFS_FCHOWN(fsp, set_owner, (gid_t)-1);
7758                 } else {
7759                         /*
7760                          * UNIX extensions calls must always operate
7761                          * on symlinks.
7762                          */
7763                         ret = SMB_VFS_LCHOWN(conn, smb_fname,
7764                                              set_owner, (gid_t)-1);
7765                 }
7766
7767                 if (ret != 0) {
7768                         status = map_nt_error_from_unix(errno);
7769                         if (delete_on_fail) {
7770                                 SMB_VFS_UNLINK(conn, smb_fname);
7771                         }
7772                         return status;
7773                 }
7774         }
7775
7776         /*
7777          * Deal with the UNIX specific gid set.
7778          */
7779
7780         if ((set_grp != (uid_t)SMB_GID_NO_CHANGE) &&
7781             (sbuf.st_ex_gid != set_grp)) {
7782                 int ret;
7783
7784                 DEBUG(10,("smb_set_file_unix_basic: SMB_SET_FILE_UNIX_BASIC "
7785                           "changing group %u for file %s\n",
7786                           (unsigned int)set_owner,
7787                           smb_fname_str_dbg(smb_fname)));
7788                 if (fsp && fsp->fh->fd != -1) {
7789                         ret = SMB_VFS_FCHOWN(fsp, set_owner, (gid_t)-1);
7790                 } else {
7791                         /*
7792                          * UNIX extensions calls must always operate
7793                          * on symlinks.
7794                          */
7795                         ret = SMB_VFS_LCHOWN(conn, smb_fname, (uid_t)-1,
7796                                   set_grp);
7797                 }
7798                 if (ret != 0) {
7799                         status = map_nt_error_from_unix(errno);
7800                         if (delete_on_fail) {
7801                                 SMB_VFS_UNLINK(conn, smb_fname);
7802                         }
7803                         return status;
7804                 }
7805         }
7806
7807         /* Deal with any size changes. */
7808
7809         status = smb_set_file_size(conn, req,
7810                                    fsp,
7811                                    smb_fname,
7812                                    &sbuf,
7813                                    size,
7814                                    false);
7815         if (!NT_STATUS_IS_OK(status)) {
7816                 return status;
7817         }
7818
7819         /* Deal with any time changes. */
7820         if (null_timespec(ft.mtime) && null_timespec(ft.atime)) {
7821                 /* No change, don't cancel anything. */
7822                 return status;
7823         }
7824
7825         id = vfs_file_id_from_sbuf(conn, &sbuf);
7826         for(all_fsps = file_find_di_first(conn->sconn, id); all_fsps;
7827                         all_fsps = file_find_di_next(all_fsps)) {
7828                 /*
7829                  * We're setting the time explicitly for UNIX.
7830                  * Cancel any pending changes over all handles.
7831                  */
7832                 all_fsps->update_write_time_on_close = false;
7833                 TALLOC_FREE(all_fsps->update_write_time_event);
7834         }
7835
7836         /*
7837          * Override the "setting_write_time"
7838          * parameter here as it almost does what
7839          * we need. Just remember if we modified
7840          * mtime and send the notify ourselves.
7841          */
7842         if (null_timespec(ft.mtime)) {
7843                 modify_mtime = false;
7844         }
7845
7846         status = smb_set_file_time(conn,
7847                                 fsp,
7848                                 smb_fname,
7849                                 &ft,
7850                                 false);
7851         if (modify_mtime) {
7852                 notify_fname(conn, NOTIFY_ACTION_MODIFIED,
7853                         FILE_NOTIFY_CHANGE_LAST_WRITE, smb_fname->base_name);
7854         }
7855         return status;
7856 }
7857
7858 /****************************************************************************
7859  Deal with SMB_SET_FILE_UNIX_INFO2.
7860 ****************************************************************************/
7861
7862 static NTSTATUS smb_set_file_unix_info2(connection_struct *conn,
7863                                         struct smb_request *req,
7864                                         const char *pdata,
7865                                         int total_data,
7866                                         files_struct *fsp,
7867                                         const struct smb_filename *smb_fname)
7868 {
7869         NTSTATUS status;
7870         uint32_t smb_fflags;
7871         uint32_t smb_fmask;
7872
7873         if (total_data < 116) {
7874                 return NT_STATUS_INVALID_PARAMETER;
7875         }
7876
7877         /* Start by setting all the fields that are common between UNIX_BASIC
7878          * and UNIX_INFO2.
7879          */
7880         status = smb_set_file_unix_basic(conn, req, pdata, total_data,
7881                                          fsp, smb_fname);
7882         if (!NT_STATUS_IS_OK(status)) {
7883                 return status;
7884         }
7885
7886         smb_fflags = IVAL(pdata, 108);
7887         smb_fmask = IVAL(pdata, 112);
7888
7889         /* NB: We should only attempt to alter the file flags if the client
7890          * sends a non-zero mask.
7891          */
7892         if (smb_fmask != 0) {
7893                 int stat_fflags = 0;
7894
7895                 if (!map_info2_flags_to_sbuf(&smb_fname->st, smb_fflags,
7896                                              smb_fmask, &stat_fflags)) {
7897                         /* Client asked to alter a flag we don't understand. */
7898                         return NT_STATUS_INVALID_PARAMETER;
7899                 }
7900
7901                 if (fsp && fsp->fh->fd != -1) {
7902                         /* XXX: we should be  using SMB_VFS_FCHFLAGS here. */
7903                         return NT_STATUS_NOT_SUPPORTED;
7904                 } else {
7905                         if (SMB_VFS_CHFLAGS(conn, smb_fname,
7906                                             stat_fflags) != 0) {
7907                                 return map_nt_error_from_unix(errno);
7908                         }
7909                 }
7910         }
7911
7912         /* XXX: need to add support for changing the create_time here. You
7913          * can do this for paths on Darwin with setattrlist(2). The right way
7914          * to hook this up is probably by extending the VFS utimes interface.
7915          */
7916
7917         return NT_STATUS_OK;
7918 }
7919
7920 /****************************************************************************
7921  Create a directory with POSIX semantics.
7922 ****************************************************************************/
7923
7924 static NTSTATUS smb_posix_mkdir(connection_struct *conn,
7925                                 struct smb_request *req,
7926                                 char **ppdata,
7927                                 int total_data,
7928                                 struct smb_filename *smb_fname,
7929                                 int *pdata_return_size)
7930 {
7931         NTSTATUS status = NT_STATUS_OK;
7932         uint32_t raw_unixmode = 0;
7933         uint32_t mod_unixmode = 0;
7934         mode_t unixmode = (mode_t)0;
7935         files_struct *fsp = NULL;
7936         uint16_t info_level_return = 0;
7937         int info;
7938         char *pdata = *ppdata;
7939
7940         if (total_data < 18) {
7941                 return NT_STATUS_INVALID_PARAMETER;
7942         }
7943
7944         raw_unixmode = IVAL(pdata,8);
7945         /* Next 4 bytes are not yet defined. */
7946
7947         status = unix_perms_from_wire(conn, &smb_fname->st, raw_unixmode,
7948                                       PERM_NEW_DIR, &unixmode);
7949         if (!NT_STATUS_IS_OK(status)) {
7950                 return status;
7951         }
7952
7953         mod_unixmode = (uint32_t)unixmode | FILE_FLAG_POSIX_SEMANTICS;
7954
7955         DEBUG(10,("smb_posix_mkdir: file %s, mode 0%o\n",
7956                   smb_fname_str_dbg(smb_fname), (unsigned int)unixmode));
7957
7958         status = SMB_VFS_CREATE_FILE(
7959                 conn,                                   /* conn */
7960                 req,                                    /* req */
7961                 0,                                      /* root_dir_fid */
7962                 smb_fname,                              /* fname */
7963                 FILE_READ_ATTRIBUTES,                   /* access_mask */
7964                 FILE_SHARE_NONE,                        /* share_access */
7965                 FILE_CREATE,                            /* create_disposition*/
7966                 FILE_DIRECTORY_FILE,                    /* create_options */
7967                 mod_unixmode,                           /* file_attributes */
7968                 0,                                      /* oplock_request */
7969                 NULL,                                   /* lease */
7970                 0,                                      /* allocation_size */
7971                 0,                                      /* private_flags */
7972                 NULL,                                   /* sd */
7973                 NULL,                                   /* ea_list */
7974                 &fsp,                                   /* result */
7975                 &info,                                  /* pinfo */
7976                 NULL, NULL);                            /* create context */
7977
7978         if (NT_STATUS_IS_OK(status)) {
7979                 close_file(req, fsp, NORMAL_CLOSE);
7980         }
7981
7982         info_level_return = SVAL(pdata,16);
7983
7984         if (info_level_return == SMB_QUERY_FILE_UNIX_BASIC) {
7985                 *pdata_return_size = 12 + SMB_FILE_UNIX_BASIC_SIZE;
7986         } else if (info_level_return ==  SMB_QUERY_FILE_UNIX_INFO2) {
7987                 *pdata_return_size = 12 + SMB_FILE_UNIX_INFO2_SIZE;
7988         } else {
7989                 *pdata_return_size = 12;
7990         }
7991
7992         /* Realloc the data size */
7993         *ppdata = (char *)SMB_REALLOC(*ppdata,*pdata_return_size);
7994         if (*ppdata == NULL) {
7995                 *pdata_return_size = 0;
7996                 return NT_STATUS_NO_MEMORY;
7997         }
7998         pdata = *ppdata;
7999
8000         SSVAL(pdata,0,NO_OPLOCK_RETURN);
8001         SSVAL(pdata,2,0); /* No fnum. */
8002         SIVAL(pdata,4,info); /* Was directory created. */
8003
8004         switch (info_level_return) {
8005                 case SMB_QUERY_FILE_UNIX_BASIC:
8006                         SSVAL(pdata,8,SMB_QUERY_FILE_UNIX_BASIC);
8007                         SSVAL(pdata,10,0); /* Padding. */
8008                         store_file_unix_basic(conn, pdata + 12, fsp,
8009                                               &smb_fname->st);
8010                         break;
8011                 case SMB_QUERY_FILE_UNIX_INFO2:
8012                         SSVAL(pdata,8,SMB_QUERY_FILE_UNIX_INFO2);
8013                         SSVAL(pdata,10,0); /* Padding. */
8014                         store_file_unix_basic_info2(conn, pdata + 12, fsp,
8015                                                     &smb_fname->st);
8016                         break;
8017                 default:
8018                         SSVAL(pdata,8,SMB_NO_INFO_LEVEL_RETURNED);
8019                         SSVAL(pdata,10,0); /* Padding. */
8020                         break;
8021         }
8022
8023         return status;
8024 }
8025
8026 /****************************************************************************
8027  Open/Create a file with POSIX semantics.
8028 ****************************************************************************/
8029
8030 #define SMB_O_RDONLY_MAPPING (FILE_READ_DATA|FILE_READ_ATTRIBUTES|FILE_READ_EA)
8031 #define SMB_O_WRONLY_MAPPING (FILE_WRITE_DATA|FILE_WRITE_ATTRIBUTES|FILE_WRITE_EA)
8032
8033 static NTSTATUS smb_posix_open(connection_struct *conn,
8034                                struct smb_request *req,
8035                                 char **ppdata,
8036                                 int total_data,
8037                                 struct smb_filename *smb_fname,
8038                                 int *pdata_return_size)
8039 {
8040         bool extended_oplock_granted = False;
8041         char *pdata = *ppdata;
8042         uint32_t flags = 0;
8043         uint32_t wire_open_mode = 0;
8044         uint32_t raw_unixmode = 0;
8045         uint32_t mod_unixmode = 0;
8046         uint32_t create_disp = 0;
8047         uint32_t access_mask = 0;
8048         uint32_t create_options = FILE_NON_DIRECTORY_FILE;
8049         NTSTATUS status = NT_STATUS_OK;
8050         mode_t unixmode = (mode_t)0;
8051         files_struct *fsp = NULL;
8052         int oplock_request = 0;
8053         int info = 0;
8054         uint16_t info_level_return = 0;
8055
8056         if (total_data < 18) {
8057                 return NT_STATUS_INVALID_PARAMETER;
8058         }
8059
8060         flags = IVAL(pdata,0);
8061         oplock_request = (flags & REQUEST_OPLOCK) ? EXCLUSIVE_OPLOCK : 0;
8062         if (oplock_request) {
8063                 oplock_request |= (flags & REQUEST_BATCH_OPLOCK) ? BATCH_OPLOCK : 0;
8064         }
8065
8066         wire_open_mode = IVAL(pdata,4);
8067
8068         if (wire_open_mode == (SMB_O_CREAT|SMB_O_DIRECTORY)) {
8069                 return smb_posix_mkdir(conn, req,
8070                                         ppdata,
8071                                         total_data,
8072                                         smb_fname,
8073                                         pdata_return_size);
8074         }
8075
8076         switch (wire_open_mode & SMB_ACCMODE) {
8077                 case SMB_O_RDONLY:
8078                         access_mask = SMB_O_RDONLY_MAPPING;
8079                         break;
8080                 case SMB_O_WRONLY:
8081                         access_mask = SMB_O_WRONLY_MAPPING;
8082                         break;
8083                 case SMB_O_RDWR:
8084                         access_mask = (SMB_O_RDONLY_MAPPING|
8085                                         SMB_O_WRONLY_MAPPING);
8086                         break;
8087                 default:
8088                         DEBUG(5,("smb_posix_open: invalid open mode 0x%x\n",
8089                                 (unsigned int)wire_open_mode ));
8090                         return NT_STATUS_INVALID_PARAMETER;
8091         }
8092
8093         wire_open_mode &= ~SMB_ACCMODE;
8094
8095         /* First take care of O_CREAT|O_EXCL interactions. */
8096         switch (wire_open_mode & (SMB_O_CREAT | SMB_O_EXCL)) {
8097                 case (SMB_O_CREAT | SMB_O_EXCL):
8098                         /* File exists fail. File not exist create. */
8099                         create_disp = FILE_CREATE;
8100                         break;
8101                 case SMB_O_CREAT:
8102                         /* File exists open. File not exist create. */
8103                         create_disp = FILE_OPEN_IF;
8104                         break;
8105                 case SMB_O_EXCL:
8106                         /* O_EXCL on its own without O_CREAT is undefined.
8107                            We deliberately ignore it as some versions of
8108                            Linux CIFSFS can send a bare O_EXCL on the
8109                            wire which other filesystems in the kernel
8110                            ignore. See bug 9519 for details. */
8111
8112                         /* Fallthrough. */
8113
8114                 case 0:
8115                         /* File exists open. File not exist fail. */
8116                         create_disp = FILE_OPEN;
8117                         break;
8118                 default:
8119                         DEBUG(5,("smb_posix_open: invalid create mode 0x%x\n",
8120                                 (unsigned int)wire_open_mode ));
8121                         return NT_STATUS_INVALID_PARAMETER;
8122         }
8123
8124         /* Next factor in the effects of O_TRUNC. */
8125         wire_open_mode &= ~(SMB_O_CREAT | SMB_O_EXCL);
8126
8127         if (wire_open_mode & SMB_O_TRUNC) {
8128                 switch (create_disp) {
8129                         case FILE_CREATE:
8130                                 /* (SMB_O_CREAT | SMB_O_EXCL | O_TRUNC) */
8131                                 /* Leave create_disp alone as
8132                                    (O_CREAT|O_EXCL|O_TRUNC) == (O_CREAT|O_EXCL)
8133                                 */
8134                                 /* File exists fail. File not exist create. */
8135                                 break;
8136                         case FILE_OPEN_IF:
8137                                 /* SMB_O_CREAT | SMB_O_TRUNC */
8138                                 /* File exists overwrite. File not exist create. */
8139                                 create_disp = FILE_OVERWRITE_IF;
8140                                 break;
8141                         case FILE_OPEN:
8142                                 /* SMB_O_TRUNC */
8143                                 /* File exists overwrite. File not exist fail. */
8144                                 create_disp = FILE_OVERWRITE;
8145                                 break;
8146                         default:
8147                                 /* Cannot get here. */
8148                                 smb_panic("smb_posix_open: logic error");
8149                                 return NT_STATUS_INVALID_PARAMETER;
8150                 }
8151         }
8152
8153         raw_unixmode = IVAL(pdata,8);
8154         /* Next 4 bytes are not yet defined. */
8155
8156         status = unix_perms_from_wire(conn, &smb_fname->st, raw_unixmode,
8157                                       (VALID_STAT(smb_fname->st) ?
8158                                           PERM_EXISTING_FILE : PERM_NEW_FILE),
8159                                       &unixmode);
8160
8161         if (!NT_STATUS_IS_OK(status)) {
8162                 return status;
8163         }
8164
8165         mod_unixmode = (uint32_t)unixmode | FILE_FLAG_POSIX_SEMANTICS;
8166
8167         if (wire_open_mode & SMB_O_SYNC) {
8168                 create_options |= FILE_WRITE_THROUGH;
8169         }
8170         if (wire_open_mode & SMB_O_APPEND) {
8171                 access_mask |= FILE_APPEND_DATA;
8172         }
8173         if (wire_open_mode & SMB_O_DIRECT) {
8174                 mod_unixmode |= FILE_FLAG_NO_BUFFERING;
8175         }
8176
8177         if ((wire_open_mode & SMB_O_DIRECTORY) ||
8178                         VALID_STAT_OF_DIR(smb_fname->st)) {
8179                 if (access_mask != SMB_O_RDONLY_MAPPING) {
8180                         return NT_STATUS_FILE_IS_A_DIRECTORY;
8181                 }
8182                 create_options &= ~FILE_NON_DIRECTORY_FILE;
8183                 create_options |= FILE_DIRECTORY_FILE;
8184         }
8185
8186         DEBUG(10,("smb_posix_open: file %s, smb_posix_flags = %u, mode 0%o\n",
8187                 smb_fname_str_dbg(smb_fname),
8188                 (unsigned int)wire_open_mode,
8189                 (unsigned int)unixmode ));
8190
8191         status = SMB_VFS_CREATE_FILE(
8192                 conn,                                   /* conn */
8193                 req,                                    /* req */
8194                 0,                                      /* root_dir_fid */
8195                 smb_fname,                              /* fname */
8196                 access_mask,                            /* access_mask */
8197                 (FILE_SHARE_READ | FILE_SHARE_WRITE |   /* share_access */
8198                     FILE_SHARE_DELETE),
8199                 create_disp,                            /* create_disposition*/
8200                 create_options,                         /* create_options */
8201                 mod_unixmode,                           /* file_attributes */
8202                 oplock_request,                         /* oplock_request */
8203                 NULL,                                   /* lease */
8204                 0,                                      /* allocation_size */
8205                 0,                                      /* private_flags */
8206                 NULL,                                   /* sd */
8207                 NULL,                                   /* ea_list */
8208                 &fsp,                                   /* result */
8209                 &info,                                  /* pinfo */
8210                 NULL, NULL);                            /* create context */
8211
8212         if (!NT_STATUS_IS_OK(status)) {
8213                 return status;
8214         }
8215
8216         if (oplock_request && lp_fake_oplocks(SNUM(conn))) {
8217                 extended_oplock_granted = True;
8218         }
8219
8220         if(oplock_request && EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type)) {
8221                 extended_oplock_granted = True;
8222         }
8223
8224         info_level_return = SVAL(pdata,16);
8225
8226         /* Allocate the correct return size. */
8227
8228         if (info_level_return == SMB_QUERY_FILE_UNIX_BASIC) {
8229                 *pdata_return_size = 12 + SMB_FILE_UNIX_BASIC_SIZE;
8230         } else if (info_level_return ==  SMB_QUERY_FILE_UNIX_INFO2) {
8231                 *pdata_return_size = 12 + SMB_FILE_UNIX_INFO2_SIZE;
8232         } else {
8233                 *pdata_return_size = 12;
8234         }
8235
8236         /* Realloc the data size */
8237         *ppdata = (char *)SMB_REALLOC(*ppdata,*pdata_return_size);
8238         if (*ppdata == NULL) {
8239                 close_file(req, fsp, ERROR_CLOSE);
8240                 *pdata_return_size = 0;
8241                 return NT_STATUS_NO_MEMORY;
8242         }
8243         pdata = *ppdata;
8244
8245         if (extended_oplock_granted) {
8246                 if (flags & REQUEST_BATCH_OPLOCK) {
8247                         SSVAL(pdata,0, BATCH_OPLOCK_RETURN);
8248                 } else {
8249                         SSVAL(pdata,0, EXCLUSIVE_OPLOCK_RETURN);
8250                 }
8251         } else if (fsp->oplock_type == LEVEL_II_OPLOCK) {
8252                 SSVAL(pdata,0, LEVEL_II_OPLOCK_RETURN);
8253         } else {
8254                 SSVAL(pdata,0,NO_OPLOCK_RETURN);
8255         }
8256
8257         SSVAL(pdata,2,fsp->fnum);
8258         SIVAL(pdata,4,info); /* Was file created etc. */
8259
8260         switch (info_level_return) {
8261                 case SMB_QUERY_FILE_UNIX_BASIC:
8262                         SSVAL(pdata,8,SMB_QUERY_FILE_UNIX_BASIC);
8263                         SSVAL(pdata,10,0); /* padding. */
8264                         store_file_unix_basic(conn, pdata + 12, fsp,
8265                                               &smb_fname->st);
8266                         break;
8267                 case SMB_QUERY_FILE_UNIX_INFO2:
8268                         SSVAL(pdata,8,SMB_QUERY_FILE_UNIX_INFO2);
8269                         SSVAL(pdata,10,0); /* padding. */
8270                         store_file_unix_basic_info2(conn, pdata + 12, fsp,
8271                                                     &smb_fname->st);
8272                         break;
8273                 default:
8274                         SSVAL(pdata,8,SMB_NO_INFO_LEVEL_RETURNED);
8275                         SSVAL(pdata,10,0); /* padding. */
8276                         break;
8277         }
8278         return NT_STATUS_OK;
8279 }
8280
8281 /****************************************************************************
8282  Delete a file with POSIX semantics.
8283 ****************************************************************************/
8284
8285 static NTSTATUS smb_posix_unlink(connection_struct *conn,
8286                                  struct smb_request *req,
8287                                 const char *pdata,
8288                                 int total_data,
8289                                 struct smb_filename *smb_fname)
8290 {
8291         NTSTATUS status = NT_STATUS_OK;
8292         files_struct *fsp = NULL;
8293         uint16_t flags = 0;
8294         char del = 1;
8295         int info = 0;
8296         int create_options = 0;
8297         int i;
8298         struct share_mode_lock *lck = NULL;
8299
8300         if (total_data < 2) {
8301                 return NT_STATUS_INVALID_PARAMETER;
8302         }
8303
8304         flags = SVAL(pdata,0);
8305
8306         if (!VALID_STAT(smb_fname->st)) {
8307                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
8308         }
8309
8310         if ((flags == SMB_POSIX_UNLINK_DIRECTORY_TARGET) &&
8311                         !VALID_STAT_OF_DIR(smb_fname->st)) {
8312                 return NT_STATUS_NOT_A_DIRECTORY;
8313         }
8314
8315         DEBUG(10,("smb_posix_unlink: %s %s\n",
8316                 (flags == SMB_POSIX_UNLINK_DIRECTORY_TARGET) ? "directory" : "file",
8317                 smb_fname_str_dbg(smb_fname)));
8318
8319         if (VALID_STAT_OF_DIR(smb_fname->st)) {
8320                 create_options |= FILE_DIRECTORY_FILE;
8321         }
8322
8323         status = SMB_VFS_CREATE_FILE(
8324                 conn,                                   /* conn */
8325                 req,                                    /* req */
8326                 0,                                      /* root_dir_fid */
8327                 smb_fname,                              /* fname */
8328                 DELETE_ACCESS,                          /* access_mask */
8329                 (FILE_SHARE_READ | FILE_SHARE_WRITE |   /* share_access */
8330                     FILE_SHARE_DELETE),
8331                 FILE_OPEN,                              /* create_disposition*/
8332                 create_options,                         /* create_options */
8333                 FILE_FLAG_POSIX_SEMANTICS|0777,         /* file_attributes */
8334                 0,                                      /* oplock_request */
8335                 NULL,                                   /* lease */
8336                 0,                                      /* allocation_size */
8337                 0,                                      /* private_flags */
8338                 NULL,                                   /* sd */
8339                 NULL,                                   /* ea_list */
8340                 &fsp,                                   /* result */
8341                 &info,                                  /* pinfo */
8342                 NULL, NULL);                            /* create context */
8343
8344         if (!NT_STATUS_IS_OK(status)) {
8345                 return status;
8346         }
8347
8348         /*
8349          * Don't lie to client. If we can't really delete due to
8350          * non-POSIX opens return SHARING_VIOLATION.
8351          */
8352
8353         lck = get_existing_share_mode_lock(talloc_tos(), fsp->file_id);
8354         if (lck == NULL) {
8355                 DEBUG(0, ("smb_posix_unlink: Could not get share mode "
8356                           "lock for file %s\n", fsp_str_dbg(fsp)));
8357                 close_file(req, fsp, NORMAL_CLOSE);
8358                 return NT_STATUS_INVALID_PARAMETER;
8359         }
8360
8361         /*
8362          * See if others still have the file open. If this is the case, then
8363          * don't delete. If all opens are POSIX delete we can set the delete
8364          * on close disposition.
8365          */
8366         for (i=0; i<lck->data->num_share_modes; i++) {
8367                 struct share_mode_entry *e = &lck->data->share_modes[i];
8368                 if (is_valid_share_mode_entry(e)) {
8369                         if (e->flags & SHARE_MODE_FLAG_POSIX_OPEN) {
8370                                 continue;
8371                         }
8372                         if (share_mode_stale_pid(lck->data, i)) {
8373                                 continue;
8374                         }
8375                         /* Fail with sharing violation. */
8376                         TALLOC_FREE(lck);
8377                         close_file(req, fsp, NORMAL_CLOSE);
8378                         return NT_STATUS_SHARING_VIOLATION;
8379                 }
8380         }
8381
8382         /*
8383          * Set the delete on close.
8384          */
8385         status = smb_set_file_disposition_info(conn,
8386                                                 &del,
8387                                                 1,
8388                                                 fsp,
8389                                                 smb_fname);
8390
8391         TALLOC_FREE(lck);
8392
8393         if (!NT_STATUS_IS_OK(status)) {
8394                 close_file(req, fsp, NORMAL_CLOSE);
8395                 return status;
8396         }
8397         return close_file(req, fsp, NORMAL_CLOSE);
8398 }
8399
8400 NTSTATUS smbd_do_setfilepathinfo(connection_struct *conn,
8401                                 struct smb_request *req,
8402                                 TALLOC_CTX *mem_ctx,
8403                                 uint16_t info_level,
8404                                 files_struct *fsp,
8405                                 struct smb_filename *smb_fname,
8406                                 char **ppdata, int total_data,
8407                                 int *ret_data_size)
8408 {
8409         char *pdata = *ppdata;
8410         NTSTATUS status = NT_STATUS_OK;
8411         int data_return_size = 0;
8412
8413         *ret_data_size = 0;
8414
8415         if (INFO_LEVEL_IS_UNIX(info_level) && !lp_unix_extensions()) {
8416                 return NT_STATUS_INVALID_LEVEL;
8417         }
8418
8419         if (!CAN_WRITE(conn)) {
8420                 /* Allow POSIX opens. The open path will deny
8421                  * any non-readonly opens. */
8422                 if (info_level != SMB_POSIX_PATH_OPEN) {
8423                         return NT_STATUS_DOS(ERRSRV, ERRaccess);
8424                 }
8425         }
8426
8427         DEBUG(3,("smbd_do_setfilepathinfo: %s (%s) info_level=%d "
8428                  "totdata=%d\n", smb_fname_str_dbg(smb_fname),
8429                  fsp_fnum_dbg(fsp),
8430                  info_level, total_data));
8431
8432         switch (info_level) {
8433
8434                 case SMB_INFO_STANDARD:
8435                 {
8436                         status = smb_set_info_standard(conn,
8437                                         pdata,
8438                                         total_data,
8439                                         fsp,
8440                                         smb_fname);
8441                         break;
8442                 }
8443
8444                 case SMB_INFO_SET_EA:
8445                 {
8446                         status = smb_info_set_ea(conn,
8447                                                 pdata,
8448                                                 total_data,
8449                                                 fsp,
8450                                                 smb_fname);
8451                         break;
8452                 }
8453
8454                 case SMB_SET_FILE_BASIC_INFO:
8455                 case SMB_FILE_BASIC_INFORMATION:
8456                 {
8457                         status = smb_set_file_basic_info(conn,
8458                                                         pdata,
8459                                                         total_data,
8460                                                         fsp,
8461                                                         smb_fname);
8462                         break;
8463                 }
8464
8465                 case SMB_FILE_ALLOCATION_INFORMATION:
8466                 case SMB_SET_FILE_ALLOCATION_INFO:
8467                 {
8468                         status = smb_set_file_allocation_info(conn, req,
8469                                                                 pdata,
8470                                                                 total_data,
8471                                                                 fsp,
8472                                                                 smb_fname);
8473                         break;
8474                 }
8475
8476                 case SMB_FILE_END_OF_FILE_INFORMATION:
8477                 case SMB_SET_FILE_END_OF_FILE_INFO:
8478                 {
8479                         /*
8480                          * XP/Win7 both fail after the createfile with
8481                          * SMB_SET_FILE_END_OF_FILE_INFO but not
8482                          * SMB_FILE_END_OF_FILE_INFORMATION (pass-through).
8483                          * The level is known here, so pass it down
8484                          * appropriately.
8485                          */
8486                         bool should_fail =
8487                             (info_level == SMB_SET_FILE_END_OF_FILE_INFO);
8488
8489                         status = smb_set_file_end_of_file_info(conn, req,
8490                                                                 pdata,
8491                                                                 total_data,
8492                                                                 fsp,
8493                                                                 smb_fname,
8494                                                                 should_fail);
8495                         break;
8496                 }
8497
8498                 case SMB_FILE_DISPOSITION_INFORMATION:
8499                 case SMB_SET_FILE_DISPOSITION_INFO: /* Set delete on close for open file. */
8500                 {
8501 #if 0
8502                         /* JRA - We used to just ignore this on a path ?
8503                          * Shouldn't this be invalid level on a pathname
8504                          * based call ?
8505                          */
8506                         if (tran_call != TRANSACT2_SETFILEINFO) {
8507                                 return ERROR_NT(NT_STATUS_INVALID_LEVEL);
8508                         }
8509 #endif
8510                         status = smb_set_file_disposition_info(conn,
8511                                                 pdata,
8512                                                 total_data,
8513                                                 fsp,
8514                                                 smb_fname);
8515                         break;
8516                 }
8517
8518                 case SMB_FILE_POSITION_INFORMATION:
8519                 {
8520                         status = smb_file_position_information(conn,
8521                                                 pdata,
8522                                                 total_data,
8523                                                 fsp);
8524                         break;
8525                 }
8526
8527                 case SMB_FILE_FULL_EA_INFORMATION:
8528                 {
8529                         status = smb_set_file_full_ea_info(conn,
8530                                                 pdata,
8531                                                 total_data,
8532                                                 fsp);
8533                         break;
8534                 }
8535
8536                 /* From tridge Samba4 :
8537                  * MODE_INFORMATION in setfileinfo (I have no
8538                  * idea what "mode information" on a file is - it takes a value of 0,
8539                  * 2, 4 or 6. What could it be?).
8540                  */
8541
8542                 case SMB_FILE_MODE_INFORMATION:
8543                 {
8544                         status = smb_file_mode_information(conn,
8545                                                 pdata,
8546                                                 total_data);
8547                         break;
8548                 }
8549
8550                 /*
8551                  * CIFS UNIX extensions.
8552                  */
8553
8554                 case SMB_SET_FILE_UNIX_BASIC:
8555                 {
8556                         status = smb_set_file_unix_basic(conn, req,
8557                                                         pdata,
8558                                                         total_data,
8559                                                         fsp,
8560                                                         smb_fname);
8561                         break;
8562                 }
8563
8564                 case SMB_SET_FILE_UNIX_INFO2:
8565                 {
8566                         status = smb_set_file_unix_info2(conn, req,
8567                                                         pdata,
8568                                                         total_data,
8569                                                         fsp,
8570                                                         smb_fname);
8571                         break;
8572                 }
8573
8574                 case SMB_SET_FILE_UNIX_LINK:
8575                 {
8576                         if (fsp) {
8577                                 /* We must have a pathname for this. */
8578                                 return NT_STATUS_INVALID_LEVEL;
8579                         }
8580                         status = smb_set_file_unix_link(conn, req, pdata,
8581                                                         total_data, smb_fname);
8582                         break;
8583                 }
8584
8585                 case SMB_SET_FILE_UNIX_HLINK:
8586                 {
8587                         if (fsp) {
8588                                 /* We must have a pathname for this. */
8589                                 return NT_STATUS_INVALID_LEVEL;
8590                         }
8591                         status = smb_set_file_unix_hlink(conn, req,
8592                                                          pdata, total_data,
8593                                                          smb_fname);
8594                         break;
8595                 }
8596
8597                 case SMB_FILE_RENAME_INFORMATION:
8598                 {
8599                         status = smb_file_rename_information(conn, req,
8600                                                              pdata, total_data,
8601                                                              fsp, smb_fname);
8602                         break;
8603                 }
8604
8605                 case SMB2_FILE_RENAME_INFORMATION_INTERNAL:
8606                 {
8607                         /* SMB2 rename information. */
8608                         status = smb2_file_rename_information(conn, req,
8609                                                              pdata, total_data,
8610                                                              fsp, smb_fname);
8611                         break;
8612                 }
8613
8614                 case SMB_FILE_LINK_INFORMATION:
8615                 {
8616                         status = smb_file_link_information(conn, req,
8617                                                         pdata, total_data,
8618                                                         fsp, smb_fname);
8619                         break;
8620                 }
8621
8622 #if defined(HAVE_POSIX_ACLS)
8623                 case SMB_SET_POSIX_ACL:
8624                 {
8625                         status = smb_set_posix_acl(conn,
8626                                                 pdata,
8627                                                 total_data,
8628                                                 fsp,
8629                                                 smb_fname);
8630                         break;
8631                 }
8632 #endif
8633
8634                 case SMB_SET_POSIX_LOCK:
8635                 {
8636                         if (!fsp) {
8637                                 return NT_STATUS_INVALID_LEVEL;
8638                         }
8639                         status = smb_set_posix_lock(conn, req,
8640                                                     pdata, total_data, fsp);
8641                         break;
8642                 }
8643
8644                 case SMB_POSIX_PATH_OPEN:
8645                 {
8646                         if (fsp) {
8647                                 /* We must have a pathname for this. */
8648                                 return NT_STATUS_INVALID_LEVEL;
8649                         }
8650
8651                         status = smb_posix_open(conn, req,
8652                                                 ppdata,
8653                                                 total_data,
8654                                                 smb_fname,
8655                                                 &data_return_size);
8656                         break;
8657                 }
8658
8659                 case SMB_POSIX_PATH_UNLINK:
8660                 {
8661                         if (fsp) {
8662                                 /* We must have a pathname for this. */
8663                                 return NT_STATUS_INVALID_LEVEL;
8664                         }
8665
8666                         status = smb_posix_unlink(conn, req,
8667                                                 pdata,
8668                                                 total_data,
8669                                                 smb_fname);
8670                         break;
8671                 }
8672
8673                 default:
8674                         return NT_STATUS_INVALID_LEVEL;
8675         }
8676
8677         if (!NT_STATUS_IS_OK(status)) {
8678                 return status;
8679         }
8680
8681         *ret_data_size = data_return_size;
8682         return NT_STATUS_OK;
8683 }
8684
8685 /****************************************************************************
8686  Reply to a TRANS2_SETFILEINFO (set file info by fileid or pathname).
8687 ****************************************************************************/
8688
8689 static void call_trans2setfilepathinfo(connection_struct *conn,
8690                                        struct smb_request *req,
8691                                        unsigned int tran_call,
8692                                        char **pparams, int total_params,
8693                                        char **ppdata, int total_data,
8694                                        unsigned int max_data_bytes)
8695 {
8696         char *params = *pparams;
8697         char *pdata = *ppdata;
8698         uint16_t info_level;
8699         struct smb_filename *smb_fname = NULL;
8700         files_struct *fsp = NULL;
8701         NTSTATUS status = NT_STATUS_OK;
8702         int data_return_size = 0;
8703
8704         if (!params) {
8705                 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
8706                 return;
8707         }
8708
8709         if (tran_call == TRANSACT2_SETFILEINFO) {
8710                 if (total_params < 4) {
8711                         reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
8712                         return;
8713                 }
8714
8715                 fsp = file_fsp(req, SVAL(params,0));
8716                 /* Basic check for non-null fsp. */
8717                 if (!check_fsp_open(conn, req, fsp)) {
8718                         return;
8719                 }
8720                 info_level = SVAL(params,2);
8721
8722                 smb_fname = cp_smb_filename(talloc_tos(), fsp->fsp_name);
8723                 if (smb_fname == NULL) {
8724                         reply_nterror(req, NT_STATUS_NO_MEMORY);
8725                         return;
8726                 }
8727
8728                 if(fsp->fh->fd == -1) {
8729                         /*
8730                          * This is actually a SETFILEINFO on a directory
8731                          * handle (returned from an NT SMB). NT5.0 seems
8732                          * to do this call. JRA.
8733                          */
8734                         if (INFO_LEVEL_IS_UNIX(info_level)) {
8735                                 /* Always do lstat for UNIX calls. */
8736                                 if (SMB_VFS_LSTAT(conn, smb_fname)) {
8737                                         DEBUG(3,("call_trans2setfilepathinfo: "
8738                                                  "SMB_VFS_LSTAT of %s failed "
8739                                                  "(%s)\n",
8740                                                  smb_fname_str_dbg(smb_fname),
8741                                                  strerror(errno)));
8742                                         reply_nterror(req, map_nt_error_from_unix(errno));
8743                                         return;
8744                                 }
8745                         } else {
8746                                 if (SMB_VFS_STAT(conn, smb_fname) != 0) {
8747                                         DEBUG(3,("call_trans2setfilepathinfo: "
8748                                                  "fileinfo of %s failed (%s)\n",
8749                                                  smb_fname_str_dbg(smb_fname),
8750                                                  strerror(errno)));
8751                                         reply_nterror(req, map_nt_error_from_unix(errno));
8752                                         return;
8753                                 }
8754                         }
8755                 } else if (fsp->print_file) {
8756                         /*
8757                          * Doing a DELETE_ON_CLOSE should cancel a print job.
8758                          */
8759                         if ((info_level == SMB_SET_FILE_DISPOSITION_INFO) && CVAL(pdata,0)) {
8760                                 fsp->fh->private_options |= NTCREATEX_OPTIONS_PRIVATE_DELETE_ON_CLOSE;
8761
8762                                 DEBUG(3,("call_trans2setfilepathinfo: "
8763                                          "Cancelling print job (%s)\n",
8764                                          fsp_str_dbg(fsp)));
8765
8766                                 SSVAL(params,0,0);
8767                                 send_trans2_replies(conn, req, NT_STATUS_OK, params, 2,
8768                                                     *ppdata, 0,
8769                                                     max_data_bytes);
8770                                 return;
8771                         } else {
8772                                 reply_nterror(req,
8773                                         NT_STATUS_OBJECT_PATH_NOT_FOUND);
8774                                 return;
8775                         }
8776                 } else {
8777                         /*
8778                          * Original code - this is an open file.
8779                          */
8780                         if (SMB_VFS_FSTAT(fsp, &smb_fname->st) != 0) {
8781                                 DEBUG(3,("call_trans2setfilepathinfo: fstat "
8782                                          "of %s failed (%s)\n", fsp_fnum_dbg(fsp),
8783                                          strerror(errno)));
8784                                 reply_nterror(req, map_nt_error_from_unix(errno));
8785                                 return;
8786                         }
8787                 }
8788         } else {
8789                 char *fname = NULL;
8790                 uint32_t ucf_flags = ucf_flags_from_smb_request(req);
8791
8792                 /* set path info */
8793                 if (total_params < 7) {
8794                         reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
8795                         return;
8796                 }
8797
8798                 info_level = SVAL(params,0);
8799                 if (req->posix_pathnames) {
8800                         srvstr_get_path_posix(req,
8801                                 params,
8802                                 req->flags2,
8803                                 &fname,
8804                                 &params[6],
8805                                 total_params - 6,
8806                                 STR_TERMINATE,
8807                                 &status);
8808                 } else {
8809                         srvstr_get_path(req,
8810                                 params,
8811                                 req->flags2,
8812                                 &fname,
8813                                 &params[6],
8814                                 total_params - 6,
8815                                 STR_TERMINATE,
8816                                 &status);
8817                 }
8818                 if (!NT_STATUS_IS_OK(status)) {
8819                         reply_nterror(req, status);
8820                         return;
8821                 }
8822
8823                 if (info_level == SMB_SET_FILE_UNIX_BASIC ||
8824                                 info_level == SMB_SET_FILE_UNIX_INFO2 ||
8825                                 info_level == SMB_FILE_RENAME_INFORMATION ||
8826                                 info_level == SMB_POSIX_PATH_UNLINK) {
8827                         ucf_flags |= UCF_UNIX_NAME_LOOKUP;
8828                 }
8829
8830                 status = filename_convert(req, conn,
8831                                          fname,
8832                                          ucf_flags,
8833                                          NULL,
8834                                          &smb_fname);
8835                 if (!NT_STATUS_IS_OK(status)) {
8836                         if (NT_STATUS_EQUAL(status,NT_STATUS_PATH_NOT_COVERED)) {
8837                                 reply_botherror(req,
8838                                                 NT_STATUS_PATH_NOT_COVERED,
8839                                                 ERRSRV, ERRbadpath);
8840                                 return;
8841                         }
8842                         reply_nterror(req, status);
8843                         return;
8844                 }
8845
8846                 if (INFO_LEVEL_IS_UNIX(info_level)) {
8847                         /*
8848                          * For CIFS UNIX extensions the target name may not exist.
8849                          */
8850
8851                         /* Always do lstat for UNIX calls. */
8852                         SMB_VFS_LSTAT(conn, smb_fname);
8853
8854                 } else if (!VALID_STAT(smb_fname->st) &&
8855                            SMB_VFS_STAT(conn, smb_fname)) {
8856                         DEBUG(3,("call_trans2setfilepathinfo: SMB_VFS_STAT of "
8857                                  "%s failed (%s)\n",
8858                                  smb_fname_str_dbg(smb_fname),
8859                                  strerror(errno)));
8860                         reply_nterror(req, map_nt_error_from_unix(errno));
8861                         return;
8862                 }
8863         }
8864
8865         DEBUG(3,("call_trans2setfilepathinfo(%d) %s (%s) info_level=%d "
8866                  "totdata=%d\n", tran_call, smb_fname_str_dbg(smb_fname),
8867                  fsp_fnum_dbg(fsp),
8868                  info_level,total_data));
8869
8870         /* Realloc the parameter size */
8871         *pparams = (char *)SMB_REALLOC(*pparams,2);
8872         if (*pparams == NULL) {
8873                 reply_nterror(req, NT_STATUS_NO_MEMORY);
8874                 return;
8875         }
8876         params = *pparams;
8877
8878         SSVAL(params,0,0);
8879
8880         status = smbd_do_setfilepathinfo(conn, req, req,
8881                                          info_level,
8882                                          fsp,
8883                                          smb_fname,
8884                                          ppdata, total_data,
8885                                          &data_return_size);
8886         if (!NT_STATUS_IS_OK(status)) {
8887                 if (open_was_deferred(req->xconn, req->mid)) {
8888                         /* We have re-scheduled this call. */
8889                         return;
8890                 }
8891                 if (blocking_lock_was_deferred_smb1(req->sconn, req->mid)) {
8892                         /* We have re-scheduled this call. */
8893                         return;
8894                 }
8895                 if (NT_STATUS_EQUAL(status,NT_STATUS_PATH_NOT_COVERED)) {
8896                         reply_botherror(req, NT_STATUS_PATH_NOT_COVERED,
8897                                         ERRSRV, ERRbadpath);
8898                         return;
8899                 }
8900                 if (info_level == SMB_POSIX_PATH_OPEN) {
8901                         reply_openerror(req, status);
8902                         return;
8903                 }
8904
8905                 /*
8906                  * Invalid EA name needs to return 2 param bytes,
8907                  * not a zero-length error packet.
8908                  */
8909                 if (NT_STATUS_EQUAL(status, STATUS_INVALID_EA_NAME)) {
8910                         send_trans2_replies(conn, req, status, params, 2, NULL, 0,
8911                                         max_data_bytes);
8912                 } else {
8913                         reply_nterror(req, status);
8914                 }
8915                 return;
8916         }
8917
8918         send_trans2_replies(conn, req, NT_STATUS_OK, params, 2, *ppdata, data_return_size,
8919                             max_data_bytes);
8920
8921         return;
8922 }
8923
8924 /****************************************************************************
8925  Reply to a TRANS2_MKDIR (make directory with extended attributes).
8926 ****************************************************************************/
8927
8928 static void call_trans2mkdir(connection_struct *conn, struct smb_request *req,
8929                              char **pparams, int total_params,
8930                              char **ppdata, int total_data,
8931                              unsigned int max_data_bytes)
8932 {
8933         struct smb_filename *smb_dname = NULL;
8934         char *params = *pparams;
8935         char *pdata = *ppdata;
8936         char *directory = NULL;
8937         NTSTATUS status = NT_STATUS_OK;
8938         struct ea_list *ea_list = NULL;
8939         uint32_t ucf_flags = ucf_flags_from_smb_request(req);
8940         TALLOC_CTX *ctx = talloc_tos();
8941
8942         if (!CAN_WRITE(conn)) {
8943                 reply_nterror(req, NT_STATUS_ACCESS_DENIED);
8944                 return;
8945         }
8946
8947         if (total_params < 5) {
8948                 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
8949                 return;
8950         }
8951
8952         if (req->posix_pathnames) {
8953                 srvstr_get_path_posix(ctx,
8954                         params,
8955                         req->flags2,
8956                         &directory,
8957                         &params[4],
8958                         total_params - 4,
8959                         STR_TERMINATE,
8960                         &status);
8961         } else {
8962                 srvstr_get_path(ctx,
8963                         params,
8964                         req->flags2,
8965                         &directory,
8966                         &params[4],
8967                         total_params - 4,
8968                         STR_TERMINATE,
8969                         &status);
8970         }
8971         if (!NT_STATUS_IS_OK(status)) {
8972                 reply_nterror(req, status);
8973                 return;
8974         }
8975
8976         DEBUG(3,("call_trans2mkdir : name = %s\n", directory));
8977
8978         status = filename_convert(ctx,
8979                                 conn,
8980                                 directory,
8981                                 ucf_flags,
8982                                 NULL,
8983                                 &smb_dname);
8984
8985         if (!NT_STATUS_IS_OK(status)) {
8986                 if (NT_STATUS_EQUAL(status,NT_STATUS_PATH_NOT_COVERED)) {
8987                         reply_botherror(req,
8988                                 NT_STATUS_PATH_NOT_COVERED,
8989                                 ERRSRV, ERRbadpath);
8990                         return;
8991                 }
8992                 reply_nterror(req, status);
8993                 return;
8994         }
8995
8996         /*
8997          * OS/2 workplace shell seems to send SET_EA requests of "null"
8998          * length (4 bytes containing IVAL 4).
8999          * They seem to have no effect. Bug #3212. JRA.
9000          */
9001
9002         if (total_data && (total_data != 4)) {
9003                 /* Any data in this call is an EA list. */
9004                 if (total_data < 10) {
9005                         reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
9006                         goto out;
9007                 }
9008
9009                 if (IVAL(pdata,0) > total_data) {
9010                         DEBUG(10,("call_trans2mkdir: bad total data size (%u) > %u\n",
9011                                 IVAL(pdata,0), (unsigned int)total_data));
9012                         reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
9013                         goto out;
9014                 }
9015
9016                 ea_list = read_ea_list(talloc_tos(), pdata + 4,
9017                                        total_data - 4);
9018                 if (!ea_list) {
9019                         reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
9020                         goto out;
9021                 }
9022
9023                 if (!lp_ea_support(SNUM(conn))) {
9024                         reply_nterror(req, NT_STATUS_EAS_NOT_SUPPORTED);
9025                         goto out;
9026                 }
9027         }
9028         /* If total_data == 4 Windows doesn't care what values
9029          * are placed in that field, it just ignores them.
9030          * The System i QNTC IBM SMB client puts bad values here,
9031          * so ignore them. */
9032
9033         status = create_directory(conn, req, smb_dname);
9034
9035         if (!NT_STATUS_IS_OK(status)) {
9036                 reply_nterror(req, status);
9037                 goto out;
9038         }
9039
9040         /* Try and set any given EA. */
9041         if (ea_list) {
9042                 status = set_ea(conn, NULL, smb_dname, ea_list);
9043                 if (!NT_STATUS_IS_OK(status)) {
9044                         reply_nterror(req, status);
9045                         goto out;
9046                 }
9047         }
9048
9049         /* Realloc the parameter and data sizes */
9050         *pparams = (char *)SMB_REALLOC(*pparams,2);
9051         if(*pparams == NULL) {
9052                 reply_nterror(req, NT_STATUS_NO_MEMORY);
9053                 goto out;
9054         }
9055         params = *pparams;
9056
9057         SSVAL(params,0,0);
9058
9059         send_trans2_replies(conn, req, NT_STATUS_OK, params, 2, *ppdata, 0, max_data_bytes);
9060
9061  out:
9062         TALLOC_FREE(smb_dname);
9063         return;
9064 }
9065
9066 /****************************************************************************
9067  Reply to a TRANS2_FINDNOTIFYFIRST (start monitoring a directory for changes).
9068  We don't actually do this - we just send a null response.
9069 ****************************************************************************/
9070
9071 static void call_trans2findnotifyfirst(connection_struct *conn,
9072                                        struct smb_request *req,
9073                                        char **pparams, int total_params,
9074                                        char **ppdata, int total_data,
9075                                        unsigned int max_data_bytes)
9076 {
9077         char *params = *pparams;
9078         uint16_t info_level;
9079
9080         if (total_params < 6) {
9081                 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
9082                 return;
9083         }
9084
9085         info_level = SVAL(params,4);
9086         DEBUG(3,("call_trans2findnotifyfirst - info_level %d\n", info_level));
9087
9088         switch (info_level) {
9089                 case 1:
9090                 case 2:
9091                         break;
9092                 default:
9093                         reply_nterror(req, NT_STATUS_INVALID_LEVEL);
9094                         return;
9095         }
9096
9097         /* Realloc the parameter and data sizes */
9098         *pparams = (char *)SMB_REALLOC(*pparams,6);
9099         if (*pparams == NULL) {
9100                 reply_nterror(req, NT_STATUS_NO_MEMORY);
9101                 return;
9102         }
9103         params = *pparams;
9104
9105         SSVAL(params,0,fnf_handle);
9106         SSVAL(params,2,0); /* No changes */
9107         SSVAL(params,4,0); /* No EA errors */
9108
9109         fnf_handle++;
9110
9111         if(fnf_handle == 0)
9112                 fnf_handle = 257;
9113
9114         send_trans2_replies(conn, req, NT_STATUS_OK, params, 6, *ppdata, 0, max_data_bytes);
9115
9116         return;
9117 }
9118
9119 /****************************************************************************
9120  Reply to a TRANS2_FINDNOTIFYNEXT (continue monitoring a directory for
9121  changes). Currently this does nothing.
9122 ****************************************************************************/
9123
9124 static void call_trans2findnotifynext(connection_struct *conn,
9125                                       struct smb_request *req,
9126                                       char **pparams, int total_params,
9127                                       char **ppdata, int total_data,
9128                                       unsigned int max_data_bytes)
9129 {
9130         char *params = *pparams;
9131
9132         DEBUG(3,("call_trans2findnotifynext\n"));
9133
9134         /* Realloc the parameter and data sizes */
9135         *pparams = (char *)SMB_REALLOC(*pparams,4);
9136         if (*pparams == NULL) {
9137                 reply_nterror(req, NT_STATUS_NO_MEMORY);
9138                 return;
9139         }
9140         params = *pparams;
9141
9142         SSVAL(params,0,0); /* No changes */
9143         SSVAL(params,2,0); /* No EA errors */
9144
9145         send_trans2_replies(conn, req, NT_STATUS_OK, params, 4, *ppdata, 0, max_data_bytes);
9146
9147         return;
9148 }
9149
9150 /****************************************************************************
9151  Reply to a TRANS2_GET_DFS_REFERRAL - Shirish Kalele <kalele@veritas.com>.
9152 ****************************************************************************/
9153
9154 static void call_trans2getdfsreferral(connection_struct *conn,
9155                                       struct smb_request *req,
9156                                       char **pparams, int total_params,
9157                                       char **ppdata, int total_data,
9158                                       unsigned int max_data_bytes)
9159 {
9160         char *params = *pparams;
9161         char *pathname = NULL;
9162         int reply_size = 0;
9163         int max_referral_level;
9164         NTSTATUS status = NT_STATUS_OK;
9165         TALLOC_CTX *ctx = talloc_tos();
9166
9167         DEBUG(10,("call_trans2getdfsreferral\n"));
9168
9169         if (total_params < 3) {
9170                 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
9171                 return;
9172         }
9173
9174         max_referral_level = SVAL(params,0);
9175
9176         if(!lp_host_msdfs()) {
9177                 reply_nterror(req, NT_STATUS_NOT_IMPLEMENTED);
9178                 return;
9179         }
9180
9181         srvstr_pull_talloc(ctx, params, req->flags2, &pathname, &params[2],
9182                     total_params - 2, STR_TERMINATE);
9183         if (!pathname) {
9184                 reply_nterror(req, NT_STATUS_NOT_FOUND);
9185                 return;
9186         }
9187         if((reply_size = setup_dfs_referral(conn, pathname, max_referral_level,
9188                                             ppdata,&status)) < 0) {
9189                 reply_nterror(req, status);
9190                 return;
9191         }
9192
9193         SSVAL((discard_const_p(uint8_t, req->inbuf)), smb_flg2,
9194               SVAL(req->inbuf,smb_flg2) | FLAGS2_DFS_PATHNAMES);
9195         send_trans2_replies(conn, req, NT_STATUS_OK, 0,0,*ppdata,reply_size, max_data_bytes);
9196
9197         return;
9198 }
9199
9200 #define LMCAT_SPL       0x53
9201 #define LMFUNC_GETJOBID 0x60
9202
9203 /****************************************************************************
9204  Reply to a TRANS2_IOCTL - used for OS/2 printing.
9205 ****************************************************************************/
9206
9207 static void call_trans2ioctl(connection_struct *conn,
9208                              struct smb_request *req,
9209                              char **pparams, int total_params,
9210                              char **ppdata, int total_data,
9211                              unsigned int max_data_bytes)
9212 {
9213         char *pdata = *ppdata;
9214         files_struct *fsp = file_fsp(req, SVAL(req->vwv+15, 0));
9215         NTSTATUS status;
9216         size_t len = 0;
9217
9218         /* check for an invalid fid before proceeding */
9219
9220         if (!fsp) {
9221                 reply_nterror(req, NT_STATUS_INVALID_HANDLE);
9222                 return;
9223         }
9224
9225         if ((SVAL(req->vwv+16, 0) == LMCAT_SPL)
9226             && (SVAL(req->vwv+17, 0) == LMFUNC_GETJOBID)) {
9227                 *ppdata = (char *)SMB_REALLOC(*ppdata, 32);
9228                 if (*ppdata == NULL) {
9229                         reply_nterror(req, NT_STATUS_NO_MEMORY);
9230                         return;
9231                 }
9232                 pdata = *ppdata;
9233
9234                 /* NOTE - THIS IS ASCII ONLY AT THE MOMENT - NOT SURE IF OS/2
9235                         CAN ACCEPT THIS IN UNICODE. JRA. */
9236
9237                 /* Job number */
9238                 SSVAL(pdata, 0, print_spool_rap_jobid(fsp->print_file));
9239
9240                 status = srvstr_push(pdata, req->flags2, pdata + 2,
9241                             lp_netbios_name(), 15,
9242                             STR_ASCII|STR_TERMINATE, &len); /* Our NetBIOS name */
9243                 if (!NT_STATUS_IS_OK(status)) {
9244                         reply_nterror(req, status);
9245                         return;
9246                 }
9247                 status = srvstr_push(pdata, req->flags2, pdata+18,
9248                             lp_servicename(talloc_tos(), SNUM(conn)), 13,
9249                             STR_ASCII|STR_TERMINATE, &len); /* Service name */
9250                 if (!NT_STATUS_IS_OK(status)) {
9251                         reply_nterror(req, status);
9252                         return;
9253                 }
9254                 send_trans2_replies(conn, req, NT_STATUS_OK, *pparams, 0, *ppdata, 32,
9255                                     max_data_bytes);
9256                 return;
9257         }
9258
9259         DEBUG(2,("Unknown TRANS2_IOCTL\n"));
9260         reply_nterror(req, NT_STATUS_NOT_IMPLEMENTED);
9261 }
9262
9263 /****************************************************************************
9264  Reply to a SMBfindclose (stop trans2 directory search).
9265 ****************************************************************************/
9266
9267 void reply_findclose(struct smb_request *req)
9268 {
9269         int dptr_num;
9270         struct smbd_server_connection *sconn = req->sconn;
9271
9272         START_PROFILE(SMBfindclose);
9273
9274         if (req->wct < 1) {
9275                 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
9276                 END_PROFILE(SMBfindclose);
9277                 return;
9278         }
9279
9280         dptr_num = SVALS(req->vwv+0, 0);
9281
9282         DEBUG(3,("reply_findclose, dptr_num = %d\n", dptr_num));
9283
9284         dptr_close(sconn, &dptr_num);
9285
9286         reply_outbuf(req, 0, 0);
9287
9288         DEBUG(3,("SMBfindclose dptr_num = %d\n", dptr_num));
9289
9290         END_PROFILE(SMBfindclose);
9291         return;
9292 }
9293
9294 /****************************************************************************
9295  Reply to a SMBfindnclose (stop FINDNOTIFYFIRST directory search).
9296 ****************************************************************************/
9297
9298 void reply_findnclose(struct smb_request *req)
9299 {
9300         int dptr_num;
9301
9302         START_PROFILE(SMBfindnclose);
9303
9304         if (req->wct < 1) {
9305                 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
9306                 END_PROFILE(SMBfindnclose);
9307                 return;
9308         }
9309
9310         dptr_num = SVAL(req->vwv+0, 0);
9311
9312         DEBUG(3,("reply_findnclose, dptr_num = %d\n", dptr_num));
9313
9314         /* We never give out valid handles for a
9315            findnotifyfirst - so any dptr_num is ok here.
9316            Just ignore it. */
9317
9318         reply_outbuf(req, 0, 0);
9319
9320         DEBUG(3,("SMB_findnclose dptr_num = %d\n", dptr_num));
9321
9322         END_PROFILE(SMBfindnclose);
9323         return;
9324 }
9325
9326 static void handle_trans2(connection_struct *conn, struct smb_request *req,
9327                           struct trans_state *state)
9328 {
9329         if (get_Protocol() >= PROTOCOL_NT1) {
9330                 req->flags2 |= 0x40; /* IS_LONG_NAME */
9331                 SSVAL((discard_const_p(uint8_t, req->inbuf)),smb_flg2,req->flags2);
9332         }
9333
9334         if (ENCRYPTION_REQUIRED(conn) && !req->encrypted) {
9335                 if (state->call != TRANSACT2_QFSINFO &&
9336                     state->call != TRANSACT2_SETFSINFO) {
9337                         DEBUG(0,("handle_trans2: encryption required "
9338                                 "with call 0x%x\n",
9339                                 (unsigned int)state->call));
9340                         reply_nterror(req, NT_STATUS_ACCESS_DENIED);
9341                         return;
9342                 }
9343         }
9344
9345         SMB_PERFCOUNT_SET_SUBOP(&req->pcd, state->call);
9346
9347         /* Now we must call the relevant TRANS2 function */
9348         switch(state->call)  {
9349         case TRANSACT2_OPEN:
9350         {
9351                 START_PROFILE(Trans2_open);
9352                 call_trans2open(conn, req,
9353                                 &state->param, state->total_param,
9354                                 &state->data, state->total_data,
9355                                 state->max_data_return);
9356                 END_PROFILE(Trans2_open);
9357                 break;
9358         }
9359
9360         case TRANSACT2_FINDFIRST:
9361         {
9362                 START_PROFILE(Trans2_findfirst);
9363                 call_trans2findfirst(conn, req,
9364                                      &state->param, state->total_param,
9365                                      &state->data, state->total_data,
9366                                      state->max_data_return);
9367                 END_PROFILE(Trans2_findfirst);
9368                 break;
9369         }
9370
9371         case TRANSACT2_FINDNEXT:
9372         {
9373                 START_PROFILE(Trans2_findnext);
9374                 call_trans2findnext(conn, req,
9375                                     &state->param, state->total_param,
9376                                     &state->data, state->total_data,
9377                                     state->max_data_return);
9378                 END_PROFILE(Trans2_findnext);
9379                 break;
9380         }
9381
9382         case TRANSACT2_QFSINFO:
9383         {
9384                 START_PROFILE(Trans2_qfsinfo);
9385                 call_trans2qfsinfo(conn, req,
9386                                    &state->param, state->total_param,
9387                                    &state->data, state->total_data,
9388                                    state->max_data_return);
9389                 END_PROFILE(Trans2_qfsinfo);
9390             break;
9391         }
9392
9393         case TRANSACT2_SETFSINFO:
9394         {
9395                 START_PROFILE(Trans2_setfsinfo);
9396                 call_trans2setfsinfo(conn, req,
9397                                      &state->param, state->total_param,
9398                                      &state->data, state->total_data,
9399                                      state->max_data_return);
9400                 END_PROFILE(Trans2_setfsinfo);
9401                 break;
9402         }
9403
9404         case TRANSACT2_QPATHINFO:
9405         case TRANSACT2_QFILEINFO:
9406         {
9407                 START_PROFILE(Trans2_qpathinfo);
9408                 call_trans2qfilepathinfo(conn, req, state->call,
9409                                          &state->param, state->total_param,
9410                                          &state->data, state->total_data,
9411                                          state->max_data_return);
9412                 END_PROFILE(Trans2_qpathinfo);
9413                 break;
9414         }
9415
9416         case TRANSACT2_SETPATHINFO:
9417         case TRANSACT2_SETFILEINFO:
9418         {
9419                 START_PROFILE(Trans2_setpathinfo);
9420                 call_trans2setfilepathinfo(conn, req, state->call,
9421                                            &state->param, state->total_param,
9422                                            &state->data, state->total_data,
9423                                            state->max_data_return);
9424                 END_PROFILE(Trans2_setpathinfo);
9425                 break;
9426         }
9427
9428         case TRANSACT2_FINDNOTIFYFIRST:
9429         {
9430                 START_PROFILE(Trans2_findnotifyfirst);
9431                 call_trans2findnotifyfirst(conn, req,
9432                                            &state->param, state->total_param,
9433                                            &state->data, state->total_data,
9434                                            state->max_data_return);
9435                 END_PROFILE(Trans2_findnotifyfirst);
9436                 break;
9437         }
9438
9439         case TRANSACT2_FINDNOTIFYNEXT:
9440         {
9441                 START_PROFILE(Trans2_findnotifynext);
9442                 call_trans2findnotifynext(conn, req,
9443                                           &state->param, state->total_param,
9444                                           &state->data, state->total_data,
9445                                           state->max_data_return);
9446                 END_PROFILE(Trans2_findnotifynext);
9447                 break;
9448         }
9449
9450         case TRANSACT2_MKDIR:
9451         {
9452                 START_PROFILE(Trans2_mkdir);
9453                 call_trans2mkdir(conn, req,
9454                                  &state->param, state->total_param,
9455                                  &state->data, state->total_data,
9456                                  state->max_data_return);
9457                 END_PROFILE(Trans2_mkdir);
9458                 break;
9459         }
9460
9461         case TRANSACT2_GET_DFS_REFERRAL:
9462         {
9463                 START_PROFILE(Trans2_get_dfs_referral);
9464                 call_trans2getdfsreferral(conn, req,
9465                                           &state->param, state->total_param,
9466                                           &state->data, state->total_data,
9467                                           state->max_data_return);
9468                 END_PROFILE(Trans2_get_dfs_referral);
9469                 break;
9470         }
9471
9472         case TRANSACT2_IOCTL:
9473         {
9474                 START_PROFILE(Trans2_ioctl);
9475                 call_trans2ioctl(conn, req,
9476                                  &state->param, state->total_param,
9477                                  &state->data, state->total_data,
9478                                  state->max_data_return);
9479                 END_PROFILE(Trans2_ioctl);
9480                 break;
9481         }
9482
9483         default:
9484                 /* Error in request */
9485                 DEBUG(2,("Unknown request %d in trans2 call\n", state->call));
9486                 reply_nterror(req, NT_STATUS_NOT_IMPLEMENTED);
9487         }
9488 }
9489
9490 /****************************************************************************
9491  Reply to a SMBtrans2.
9492  ****************************************************************************/
9493
9494 void reply_trans2(struct smb_request *req)
9495 {
9496         connection_struct *conn = req->conn;
9497         unsigned int dsoff;
9498         unsigned int dscnt;
9499         unsigned int psoff;
9500         unsigned int pscnt;
9501         unsigned int tran_call;
9502         struct trans_state *state;
9503         NTSTATUS result;
9504
9505         START_PROFILE(SMBtrans2);
9506
9507         if (req->wct < 14) {
9508                 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
9509                 END_PROFILE(SMBtrans2);
9510                 return;
9511         }
9512
9513         dsoff = SVAL(req->vwv+12, 0);
9514         dscnt = SVAL(req->vwv+11, 0);
9515         psoff = SVAL(req->vwv+10, 0);
9516         pscnt = SVAL(req->vwv+9, 0);
9517         tran_call = SVAL(req->vwv+14, 0);
9518
9519         result = allow_new_trans(conn->pending_trans, req->mid);
9520         if (!NT_STATUS_IS_OK(result)) {
9521                 DEBUG(2, ("Got invalid trans2 request: %s\n",
9522                           nt_errstr(result)));
9523                 reply_nterror(req, result);
9524                 END_PROFILE(SMBtrans2);
9525                 return;
9526         }
9527
9528         if (IS_IPC(conn)) {
9529                 switch (tran_call) {
9530                 /* List the allowed trans2 calls on IPC$ */
9531                 case TRANSACT2_OPEN:
9532                 case TRANSACT2_GET_DFS_REFERRAL:
9533                 case TRANSACT2_QFILEINFO:
9534                 case TRANSACT2_QFSINFO:
9535                 case TRANSACT2_SETFSINFO:
9536                         break;
9537                 default:
9538                         reply_nterror(req, NT_STATUS_ACCESS_DENIED);
9539                         END_PROFILE(SMBtrans2);
9540                         return;
9541                 }
9542         }
9543
9544         if ((state = talloc(conn, struct trans_state)) == NULL) {
9545                 DEBUG(0, ("talloc failed\n"));
9546                 reply_nterror(req, NT_STATUS_NO_MEMORY);
9547                 END_PROFILE(SMBtrans2);
9548                 return;
9549         }
9550
9551         state->cmd = SMBtrans2;
9552
9553         state->mid = req->mid;
9554         state->vuid = req->vuid;
9555         state->setup_count = SVAL(req->vwv+13, 0);
9556         state->setup = NULL;
9557         state->total_param = SVAL(req->vwv+0, 0);
9558         state->param = NULL;
9559         state->total_data =  SVAL(req->vwv+1, 0);
9560         state->data = NULL;
9561         state->max_param_return = SVAL(req->vwv+2, 0);
9562         state->max_data_return  = SVAL(req->vwv+3, 0);
9563         state->max_setup_return = SVAL(req->vwv+4, 0);
9564         state->close_on_completion = BITSETW(req->vwv+5, 0);
9565         state->one_way = BITSETW(req->vwv+5, 1);
9566
9567         state->call = tran_call;
9568
9569         /* All trans2 messages we handle have smb_sucnt == 1 - ensure this
9570            is so as a sanity check */
9571         if (state->setup_count != 1) {
9572                 /*
9573                  * Need to have rc=0 for ioctl to get job id for OS/2.
9574                  *  Network printing will fail if function is not successful.
9575                  *  Similar function in reply.c will be used if protocol
9576                  *  is LANMAN1.0 instead of LM1.2X002.
9577                  *  Until DosPrintSetJobInfo with PRJINFO3 is supported,
9578                  *  outbuf doesn't have to be set(only job id is used).
9579                  */
9580                 if ( (state->setup_count == 4)
9581                      && (tran_call == TRANSACT2_IOCTL)
9582                      && (SVAL(req->vwv+16, 0) == LMCAT_SPL)
9583                      && (SVAL(req->vwv+17, 0) == LMFUNC_GETJOBID)) {
9584                         DEBUG(2,("Got Trans2 DevIOctl jobid\n"));
9585                 } else {
9586                         DEBUG(2,("Invalid smb_sucnt in trans2 call(%u)\n",state->setup_count));
9587                         DEBUG(2,("Transaction is %d\n",tran_call));
9588                         TALLOC_FREE(state);
9589                         reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
9590                         END_PROFILE(SMBtrans2);
9591                         return;
9592                 }
9593         }
9594
9595         if ((dscnt > state->total_data) || (pscnt > state->total_param))
9596                 goto bad_param;
9597
9598         if (state->total_data) {
9599
9600                 if (trans_oob(state->total_data, 0, dscnt)
9601                     || trans_oob(smb_len(req->inbuf), dsoff, dscnt)) {
9602                         goto bad_param;
9603                 }
9604
9605                 /* Can't use talloc here, the core routines do realloc on the
9606                  * params and data. */
9607                 state->data = (char *)SMB_MALLOC(state->total_data);
9608                 if (state->data == NULL) {
9609                         DEBUG(0,("reply_trans2: data malloc fail for %u "
9610                                  "bytes !\n", (unsigned int)state->total_data));
9611                         TALLOC_FREE(state);
9612                         reply_nterror(req, NT_STATUS_NO_MEMORY);
9613                         END_PROFILE(SMBtrans2);
9614                         return;
9615                 }
9616
9617                 memcpy(state->data,smb_base(req->inbuf)+dsoff,dscnt);
9618         }
9619
9620         if (state->total_param) {
9621
9622                 if (trans_oob(state->total_param, 0, pscnt)
9623                     || trans_oob(smb_len(req->inbuf), psoff, pscnt)) {
9624                         goto bad_param;
9625                 }
9626
9627                 /* Can't use talloc here, the core routines do realloc on the
9628                  * params and data. */
9629                 state->param = (char *)SMB_MALLOC(state->total_param);
9630                 if (state->param == NULL) {
9631                         DEBUG(0,("reply_trans: param malloc fail for %u "
9632                                  "bytes !\n", (unsigned int)state->total_param));
9633                         SAFE_FREE(state->data);
9634                         TALLOC_FREE(state);
9635                         reply_nterror(req, NT_STATUS_NO_MEMORY);
9636                         END_PROFILE(SMBtrans2);
9637                         return;
9638                 }
9639
9640                 memcpy(state->param,smb_base(req->inbuf)+psoff,pscnt);
9641         }
9642
9643         state->received_data  = dscnt;
9644         state->received_param = pscnt;
9645
9646         if ((state->received_param == state->total_param) &&
9647             (state->received_data == state->total_data)) {
9648
9649                 handle_trans2(conn, req, state);
9650
9651                 SAFE_FREE(state->data);
9652                 SAFE_FREE(state->param);
9653                 TALLOC_FREE(state);
9654                 END_PROFILE(SMBtrans2);
9655                 return;
9656         }
9657
9658         DLIST_ADD(conn->pending_trans, state);
9659
9660         /* We need to send an interim response then receive the rest
9661            of the parameter/data bytes */
9662         reply_outbuf(req, 0, 0);
9663         show_msg((char *)req->outbuf);
9664         END_PROFILE(SMBtrans2);
9665         return;
9666
9667   bad_param:
9668
9669         DEBUG(0,("reply_trans2: invalid trans parameters\n"));
9670         SAFE_FREE(state->data);
9671         SAFE_FREE(state->param);
9672         TALLOC_FREE(state);
9673         END_PROFILE(SMBtrans2);
9674         reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
9675 }
9676
9677
9678 /****************************************************************************
9679  Reply to a SMBtranss2
9680  ****************************************************************************/
9681
9682 void reply_transs2(struct smb_request *req)
9683 {
9684         connection_struct *conn = req->conn;
9685         unsigned int pcnt,poff,dcnt,doff,pdisp,ddisp;
9686         struct trans_state *state;
9687
9688         START_PROFILE(SMBtranss2);
9689
9690         show_msg((const char *)req->inbuf);
9691
9692         /* Windows clients expect all replies to
9693            a transact secondary (SMBtranss2 0x33)
9694            to have a command code of transact
9695            (SMBtrans2 0x32). See bug #8989
9696            and also [MS-CIFS] section 2.2.4.47.2
9697            for details.
9698         */
9699         req->cmd = SMBtrans2;
9700
9701         if (req->wct < 8) {
9702                 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
9703                 END_PROFILE(SMBtranss2);
9704                 return;
9705         }
9706
9707         for (state = conn->pending_trans; state != NULL;
9708              state = state->next) {
9709                 if (state->mid == req->mid) {
9710                         break;
9711                 }
9712         }
9713
9714         if ((state == NULL) || (state->cmd != SMBtrans2)) {
9715                 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
9716                 END_PROFILE(SMBtranss2);
9717                 return;
9718         }
9719
9720         /* Revise state->total_param and state->total_data in case they have
9721            changed downwards */
9722
9723         if (SVAL(req->vwv+0, 0) < state->total_param)
9724                 state->total_param = SVAL(req->vwv+0, 0);
9725         if (SVAL(req->vwv+1, 0) < state->total_data)
9726                 state->total_data = SVAL(req->vwv+1, 0);
9727
9728         pcnt = SVAL(req->vwv+2, 0);
9729         poff = SVAL(req->vwv+3, 0);
9730         pdisp = SVAL(req->vwv+4, 0);
9731
9732         dcnt = SVAL(req->vwv+5, 0);
9733         doff = SVAL(req->vwv+6, 0);
9734         ddisp = SVAL(req->vwv+7, 0);
9735
9736         state->received_param += pcnt;
9737         state->received_data += dcnt;
9738
9739         if ((state->received_data > state->total_data) ||
9740             (state->received_param > state->total_param))
9741                 goto bad_param;
9742
9743         if (pcnt) {
9744                 if (trans_oob(state->total_param, pdisp, pcnt)
9745                     || trans_oob(smb_len(req->inbuf), poff, pcnt)) {
9746                         goto bad_param;
9747                 }
9748                 memcpy(state->param+pdisp,smb_base(req->inbuf)+poff,pcnt);
9749         }
9750
9751         if (dcnt) {
9752                 if (trans_oob(state->total_data, ddisp, dcnt)
9753                     || trans_oob(smb_len(req->inbuf), doff, dcnt)) {
9754                         goto bad_param;
9755                 }
9756                 memcpy(state->data+ddisp, smb_base(req->inbuf)+doff,dcnt);
9757         }
9758
9759         if ((state->received_param < state->total_param) ||
9760             (state->received_data < state->total_data)) {
9761                 END_PROFILE(SMBtranss2);
9762                 return;
9763         }
9764
9765         handle_trans2(conn, req, state);
9766
9767         DLIST_REMOVE(conn->pending_trans, state);
9768         SAFE_FREE(state->data);
9769         SAFE_FREE(state->param);
9770         TALLOC_FREE(state);
9771
9772         END_PROFILE(SMBtranss2);
9773         return;
9774
9775   bad_param:
9776
9777         DEBUG(0,("reply_transs2: invalid trans parameters\n"));
9778         DLIST_REMOVE(conn->pending_trans, state);
9779         SAFE_FREE(state->data);
9780         SAFE_FREE(state->param);
9781         TALLOC_FREE(state);
9782         reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
9783         END_PROFILE(SMBtranss2);
9784         return;
9785 }