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         /* We don't need to check for VOL here as this is returned by
2871                 a different TRANS2 call. */
2872
2873         DEBUG(8,("dirpath=<%s> dontdescend=<%s>\n",
2874                  directory,lp_dont_descend(talloc_tos(), SNUM(conn))));
2875         if (in_list(directory,
2876                         lp_dont_descend(talloc_tos(), SNUM(conn)),
2877                         conn->case_sensitive)) {
2878                 dont_descend = True;
2879         }
2880
2881         p = pdata;
2882         space_remaining = max_data_bytes;
2883         out_of_space = False;
2884
2885         for (i=0;(i<maxentries) && !finished && !out_of_space;i++) {
2886                 bool got_exact_match = False;
2887
2888                 /* this is a heuristic to avoid seeking the dirptr except when
2889                         absolutely necessary. It allows for a filename of about 40 chars */
2890                 if (space_remaining < DIRLEN_GUESS && numentries > 0) {
2891                         out_of_space = True;
2892                         finished = False;
2893                 } else {
2894                         ntstatus = get_lanman2_dir_entry(talloc_tos(),
2895                                         conn,
2896                                         dirptr,
2897                                         req->flags2,
2898                                         mask,dirtype,info_level,
2899                                         requires_resume_key,dont_descend,
2900                                         ask_sharemode,
2901                                         &p,pdata,data_end,
2902                                         space_remaining,
2903                                         &got_exact_match,
2904                                         &last_entry_off, ea_list);
2905                         if (NT_STATUS_EQUAL(ntstatus,
2906                                         NT_STATUS_ILLEGAL_CHARACTER)) {
2907                                 /*
2908                                  * Bad character conversion on name. Ignore this
2909                                  * entry.
2910                                  */
2911                                 continue;
2912                         }
2913                         if (NT_STATUS_EQUAL(ntstatus, STATUS_MORE_ENTRIES)) {
2914                                 out_of_space = true;
2915                         } else {
2916                                 finished = !NT_STATUS_IS_OK(ntstatus);
2917                         }
2918                 }
2919
2920                 if (!finished && !out_of_space)
2921                         numentries++;
2922
2923                 /*
2924                  * As an optimisation if we know we aren't looking
2925                  * for a wildcard name (ie. the name matches the wildcard exactly)
2926                  * then we can finish on any (first) match.
2927                  * This speeds up large directory searches. JRA.
2928                  */
2929
2930                 if(got_exact_match)
2931                         finished = True;
2932
2933                 /* Ensure space_remaining never goes -ve. */
2934                 if (PTR_DIFF(p,pdata) > max_data_bytes) {
2935                         space_remaining = 0;
2936                         out_of_space = true;
2937                 } else {
2938                         space_remaining = max_data_bytes - PTR_DIFF(p,pdata);
2939                 }
2940         }
2941
2942         /* Check if we can close the dirptr */
2943         if(close_after_first || (finished && close_if_end)) {
2944                 DEBUG(5,("call_trans2findfirst - (2) closing dptr_num %d\n", dptr_num));
2945                 dptr_close(sconn, &dptr_num);
2946         }
2947
2948         /*
2949          * If there are no matching entries we must return ERRDOS/ERRbadfile -
2950          * from observation of NT. NB. This changes to ERRDOS,ERRnofiles if
2951          * the protocol level is less than NT1. Tested with smbclient. JRA.
2952          * This should fix the OS/2 client bug #2335.
2953          */
2954
2955         if(numentries == 0) {
2956                 dptr_close(sconn, &dptr_num);
2957                 if (get_Protocol() < PROTOCOL_NT1) {
2958                         reply_force_doserror(req, ERRDOS, ERRnofiles);
2959                         goto out;
2960                 } else {
2961                         reply_botherror(req, NT_STATUS_NO_SUCH_FILE,
2962                                         ERRDOS, ERRbadfile);
2963                         goto out;
2964                 }
2965         }
2966
2967         /* At this point pdata points to numentries directory entries. */
2968
2969         /* Set up the return parameter block */
2970         SSVAL(params,0,dptr_num);
2971         SSVAL(params,2,numentries);
2972         SSVAL(params,4,finished);
2973         SSVAL(params,6,0); /* Never an EA error */
2974         SSVAL(params,8,last_entry_off);
2975
2976         send_trans2_replies(conn, req, NT_STATUS_OK, params, 10, pdata, PTR_DIFF(p,pdata),
2977                             max_data_bytes);
2978
2979         if ((! *directory) && dptr_path(sconn, dptr_num)) {
2980                 directory = talloc_strdup(talloc_tos(),dptr_path(sconn, dptr_num));
2981                 if (!directory) {
2982                         reply_nterror(req, NT_STATUS_NO_MEMORY);
2983                 }
2984         }
2985
2986         DEBUG( 4, ( "%s mask=%s directory=%s dirtype=%d numentries=%d\n",
2987                 smb_fn_name(req->cmd),
2988                 mask, directory, dirtype, numentries ) );
2989
2990         /*
2991          * Force a name mangle here to ensure that the
2992          * mask as an 8.3 name is top of the mangled cache.
2993          * The reasons for this are subtle. Don't remove
2994          * this code unless you know what you are doing
2995          * (see PR#13758). JRA.
2996          */
2997
2998         if(!mangle_is_8_3_wildcards( mask, False, conn->params)) {
2999                 char mangled_name[13];
3000                 name_to_8_3(mask, mangled_name, True, conn->params);
3001         }
3002  out:
3003
3004         if (as_root) {
3005                 unbecome_root();
3006         }
3007
3008         TALLOC_FREE(smb_dname);
3009         return;
3010 }
3011
3012 /****************************************************************************
3013  Reply to a TRANS2_FINDNEXT.
3014 ****************************************************************************/
3015
3016 static void call_trans2findnext(connection_struct *conn,
3017                                 struct smb_request *req,
3018                                 char **pparams, int total_params,
3019                                 char **ppdata, int total_data,
3020                                 unsigned int max_data_bytes)
3021 {
3022         /* We must be careful here that we don't return more than the
3023                 allowed number of data bytes. If this means returning fewer than
3024                 maxentries then so be it. We assume that the redirector has
3025                 enough room for the fixed number of parameter bytes it has
3026                 requested. */
3027         char *params = *pparams;
3028         char *pdata = *ppdata;
3029         char *data_end;
3030         int dptr_num;
3031         int maxentries;
3032         uint16_t info_level;
3033         uint32_t resume_key;
3034         uint16_t findnext_flags;
3035         bool close_after_request;
3036         bool close_if_end;
3037         bool requires_resume_key;
3038         bool continue_bit;
3039         bool mask_contains_wcard = False;
3040         char *resume_name = NULL;
3041         const char *mask = NULL;
3042         const char *directory = NULL;
3043         char *p = NULL;
3044         uint16_t dirtype;
3045         int numentries = 0;
3046         int i, last_entry_off=0;
3047         bool finished = False;
3048         bool dont_descend = False;
3049         bool out_of_space = False;
3050         int space_remaining;
3051         struct ea_list *ea_list = NULL;
3052         NTSTATUS ntstatus = NT_STATUS_OK;
3053         bool ask_sharemode = lp_parm_bool(SNUM(conn), "smbd", "search ask sharemode", true);
3054         TALLOC_CTX *ctx = talloc_tos();
3055         struct dptr_struct *dirptr;
3056         struct smbd_server_connection *sconn = req->sconn;
3057         bool backup_priv = false;
3058         bool as_root = false;
3059
3060         if (total_params < 13) {
3061                 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
3062                 return;
3063         }
3064
3065         dptr_num = SVAL(params,0);
3066         maxentries = SVAL(params,2);
3067         info_level = SVAL(params,4);
3068         resume_key = IVAL(params,6);
3069         findnext_flags = SVAL(params,10);
3070         close_after_request = (findnext_flags & FLAG_TRANS2_FIND_CLOSE);
3071         close_if_end = (findnext_flags & FLAG_TRANS2_FIND_CLOSE_IF_END);
3072         requires_resume_key = (findnext_flags & FLAG_TRANS2_FIND_REQUIRE_RESUME);
3073         continue_bit = (findnext_flags & FLAG_TRANS2_FIND_CONTINUE);
3074
3075         if (!continue_bit) {
3076                 /* We only need resume_name if continue_bit is zero. */
3077                 if (req->posix_pathnames) {
3078                         srvstr_get_path_wcard_posix(ctx,
3079                                 params,
3080                                 req->flags2,
3081                                 &resume_name,
3082                                 params+12,
3083                                 total_params - 12,
3084                                 STR_TERMINATE,
3085                                 &ntstatus,
3086                                 &mask_contains_wcard);
3087                 } else {
3088                         srvstr_get_path_wcard(ctx,
3089                                 params,
3090                                 req->flags2,
3091                                 &resume_name,
3092                                 params+12,
3093                                 total_params - 12,
3094                                 STR_TERMINATE,
3095                                 &ntstatus,
3096                                 &mask_contains_wcard);
3097                 }
3098                 if (!NT_STATUS_IS_OK(ntstatus)) {
3099                         /* Win9x or OS/2 can send a resume name of ".." or ".". This will cause the parser to
3100                            complain (it thinks we're asking for the directory above the shared
3101                            path or an invalid name). Catch this as the resume name is only compared, never used in
3102                            a file access. JRA. */
3103                         srvstr_pull_talloc(ctx, params, req->flags2,
3104                                 &resume_name, params+12,
3105                                 total_params - 12,
3106                                 STR_TERMINATE);
3107
3108                         if (!resume_name || !(ISDOT(resume_name) || ISDOTDOT(resume_name))) {
3109                                 reply_nterror(req, ntstatus);
3110                                 return;
3111                         }
3112                 }
3113         }
3114
3115         DEBUG(3,("call_trans2findnext: dirhandle = %d, max_data_bytes = %d, maxentries = %d, \
3116 close_after_request=%d, close_if_end = %d requires_resume_key = %d \
3117 resume_key = %d resume name = %s continue=%d level = %d\n",
3118                 dptr_num, max_data_bytes, maxentries, close_after_request, close_if_end,
3119                 requires_resume_key, resume_key,
3120                 resume_name ? resume_name : "(NULL)", continue_bit, info_level));
3121
3122         if (!maxentries) {
3123                 /* W2K3 seems to treat zero as 1. */
3124                 maxentries = 1;
3125         }
3126
3127         switch (info_level) {
3128                 case SMB_FIND_INFO_STANDARD:
3129                 case SMB_FIND_EA_SIZE:
3130                 case SMB_FIND_EA_LIST:
3131                 case SMB_FIND_FILE_DIRECTORY_INFO:
3132                 case SMB_FIND_FILE_FULL_DIRECTORY_INFO:
3133                 case SMB_FIND_FILE_NAMES_INFO:
3134                 case SMB_FIND_FILE_BOTH_DIRECTORY_INFO:
3135                 case SMB_FIND_ID_FULL_DIRECTORY_INFO:
3136                 case SMB_FIND_ID_BOTH_DIRECTORY_INFO:
3137                         break;
3138                 case SMB_FIND_FILE_UNIX:
3139                 case SMB_FIND_FILE_UNIX_INFO2:
3140                         /* Always use filesystem for UNIX mtime query. */
3141                         ask_sharemode = false;
3142                         if (!lp_unix_extensions()) {
3143                                 reply_nterror(req, NT_STATUS_INVALID_LEVEL);
3144                                 return;
3145                         }
3146                         break;
3147                 default:
3148                         reply_nterror(req, NT_STATUS_INVALID_LEVEL);
3149                         return;
3150         }
3151
3152         if (info_level == SMB_FIND_EA_LIST) {
3153                 uint32_t ea_size;
3154
3155                 if (total_data < 4) {
3156                         reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
3157                         return;
3158                 }
3159
3160                 ea_size = IVAL(pdata,0);
3161                 if (ea_size != total_data) {
3162                         DEBUG(4,("call_trans2findnext: Rejecting EA request with incorrect \
3163 total_data=%u (should be %u)\n", (unsigned int)total_data, (unsigned int)IVAL(pdata,0) ));
3164                         reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
3165                         return;
3166                 }
3167
3168                 if (!lp_ea_support(SNUM(conn))) {
3169                         reply_nterror(req, NT_STATUS_EAS_NOT_SUPPORTED);
3170                         return;
3171                 }
3172
3173                 /* Pull out the list of names. */
3174                 ea_list = read_ea_name_list(ctx, pdata + 4, ea_size - 4);
3175                 if (!ea_list) {
3176                         reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
3177                         return;
3178                 }
3179         }
3180
3181         if (max_data_bytes + DIR_ENTRY_SAFETY_MARGIN < max_data_bytes) {
3182                 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
3183                 return;
3184         }
3185
3186         *ppdata = (char *)SMB_REALLOC(
3187                 *ppdata, max_data_bytes + DIR_ENTRY_SAFETY_MARGIN);
3188         if(*ppdata == NULL) {
3189                 reply_nterror(req, NT_STATUS_NO_MEMORY);
3190                 return;
3191         }
3192
3193         pdata = *ppdata;
3194         data_end = pdata + max_data_bytes + DIR_ENTRY_SAFETY_MARGIN - 1;
3195
3196         /*
3197          * squash valgrind "writev(vector[...]) points to uninitialised byte(s)"
3198          * error.
3199          */
3200         memset(pdata + total_data, 0, (max_data_bytes + DIR_ENTRY_SAFETY_MARGIN) - total_data);
3201         /* Realloc the params space */
3202         *pparams = (char *)SMB_REALLOC(*pparams, 6*SIZEOFWORD);
3203         if(*pparams == NULL ) {
3204                 reply_nterror(req, NT_STATUS_NO_MEMORY);
3205                 return;
3206         }
3207
3208         params = *pparams;
3209
3210         /* Check that the dptr is valid */
3211         if(!(dirptr = dptr_fetch_lanman2(sconn, dptr_num))) {
3212                 reply_nterror(req, STATUS_NO_MORE_FILES);
3213                 return;
3214         }
3215
3216         directory = dptr_path(sconn, dptr_num);
3217
3218         /* Get the wildcard mask from the dptr */
3219         if((mask = dptr_wcard(sconn, dptr_num))== NULL) {
3220                 DEBUG(2,("dptr_num %d has no wildcard\n", dptr_num));
3221                 reply_nterror(req, STATUS_NO_MORE_FILES);
3222                 return;
3223         }
3224
3225         /* Get the attr mask from the dptr */
3226         dirtype = dptr_attr(sconn, dptr_num);
3227
3228         backup_priv = dptr_get_priv(dirptr);
3229
3230         DEBUG(3,("dptr_num is %d, mask = %s, attr = %x, dirptr=(0x%lX,%ld) "
3231                 "backup_priv = %d\n",
3232                 dptr_num, mask, dirtype,
3233                 (long)dirptr,
3234                 dptr_TellDir(dirptr),
3235                 (int)backup_priv));
3236
3237         /* We don't need to check for VOL here as this is returned by
3238                 a different TRANS2 call. */
3239
3240         DEBUG(8,("dirpath=<%s> dontdescend=<%s>\n",
3241                  directory,lp_dont_descend(ctx, SNUM(conn))));
3242         if (in_list(directory,lp_dont_descend(ctx, SNUM(conn)),conn->case_sensitive))
3243                 dont_descend = True;
3244
3245         p = pdata;
3246         space_remaining = max_data_bytes;
3247         out_of_space = False;
3248
3249         if (backup_priv) {
3250                 become_root();
3251                 as_root = true;
3252         }
3253
3254         /*
3255          * Seek to the correct position. We no longer use the resume key but
3256          * depend on the last file name instead.
3257          */
3258
3259         if(!continue_bit && resume_name && *resume_name) {
3260                 SMB_STRUCT_STAT st;
3261
3262                 long current_pos = 0;
3263                 /*
3264                  * Remember, name_to_8_3 is called by
3265                  * get_lanman2_dir_entry(), so the resume name
3266                  * could be mangled. Ensure we check the unmangled name.
3267                  */
3268
3269                 if (mangle_is_mangled(resume_name, conn->params)) {
3270                         char *new_resume_name = NULL;
3271                         mangle_lookup_name_from_8_3(ctx,
3272                                                 resume_name,
3273                                                 &new_resume_name,
3274                                                 conn->params);
3275                         if (new_resume_name) {
3276                                 resume_name = new_resume_name;
3277                         }
3278                 }
3279
3280                 /*
3281                  * Fix for NT redirector problem triggered by resume key indexes
3282                  * changing between directory scans. We now return a resume key of 0
3283                  * and instead look for the filename to continue from (also given
3284                  * to us by NT/95/smbfs/smbclient). If no other scans have been done between the
3285                  * findfirst/findnext (as is usual) then the directory pointer
3286                  * should already be at the correct place.
3287                  */
3288
3289                 finished = !dptr_SearchDir(dirptr, resume_name, &current_pos, &st);
3290         } /* end if resume_name && !continue_bit */
3291
3292         for (i=0;(i<(int)maxentries) && !finished && !out_of_space ;i++) {
3293                 bool got_exact_match = False;
3294
3295                 /* this is a heuristic to avoid seeking the dirptr except when
3296                         absolutely necessary. It allows for a filename of about 40 chars */
3297                 if (space_remaining < DIRLEN_GUESS && numentries > 0) {
3298                         out_of_space = True;
3299                         finished = False;
3300                 } else {
3301                         ntstatus = get_lanman2_dir_entry(ctx,
3302                                                 conn,
3303                                                 dirptr,
3304                                                 req->flags2,
3305                                                 mask,dirtype,info_level,
3306                                                 requires_resume_key,dont_descend,
3307                                                 ask_sharemode,
3308                                                 &p,pdata,data_end,
3309                                                 space_remaining,
3310                                                 &got_exact_match,
3311                                                 &last_entry_off, ea_list);
3312                         if (NT_STATUS_EQUAL(ntstatus,
3313                                         NT_STATUS_ILLEGAL_CHARACTER)) {
3314                                 /*
3315                                  * Bad character conversion on name. Ignore this
3316                                  * entry.
3317                                  */
3318                                 continue;
3319                         }
3320                         if (NT_STATUS_EQUAL(ntstatus, STATUS_MORE_ENTRIES)) {
3321                                 out_of_space = true;
3322                         } else {
3323                                 finished = !NT_STATUS_IS_OK(ntstatus);
3324                         }
3325                 }
3326
3327                 if (!finished && !out_of_space)
3328                         numentries++;
3329
3330                 /*
3331                  * As an optimisation if we know we aren't looking
3332                  * for a wildcard name (ie. the name matches the wildcard exactly)
3333                  * then we can finish on any (first) match.
3334                  * This speeds up large directory searches. JRA.
3335                  */
3336
3337                 if(got_exact_match)
3338                         finished = True;
3339
3340                 space_remaining = max_data_bytes - PTR_DIFF(p,pdata);
3341         }
3342
3343         DEBUG( 3, ( "%s mask=%s directory=%s dirtype=%d numentries=%d\n",
3344                 smb_fn_name(req->cmd),
3345                 mask, directory, dirtype, numentries ) );
3346
3347         /* Check if we can close the dirptr */
3348         if(close_after_request || (finished && close_if_end)) {
3349                 DEBUG(5,("call_trans2findnext: closing dptr_num = %d\n", dptr_num));
3350                 dptr_close(sconn, &dptr_num); /* This frees up the saved mask */
3351         }
3352
3353         if (as_root) {
3354                 unbecome_root();
3355         }
3356
3357         /* Set up the return parameter block */
3358         SSVAL(params,0,numentries);
3359         SSVAL(params,2,finished);
3360         SSVAL(params,4,0); /* Never an EA error */
3361         SSVAL(params,6,last_entry_off);
3362
3363         send_trans2_replies(conn, req, NT_STATUS_OK, params, 8, pdata, PTR_DIFF(p,pdata),
3364                             max_data_bytes);
3365
3366         return;
3367 }
3368
3369 unsigned char *create_volume_objectid(connection_struct *conn, unsigned char objid[16])
3370 {
3371         E_md4hash(lp_servicename(talloc_tos(), SNUM(conn)),objid);
3372         return objid;
3373 }
3374
3375 static void samba_extended_info_version(struct smb_extended_info *extended_info)
3376 {
3377         SMB_ASSERT(extended_info != NULL);
3378
3379         extended_info->samba_magic = SAMBA_EXTENDED_INFO_MAGIC;
3380         extended_info->samba_version = ((SAMBA_VERSION_MAJOR & 0xff) << 24)
3381                                        | ((SAMBA_VERSION_MINOR & 0xff) << 16)
3382                                        | ((SAMBA_VERSION_RELEASE & 0xff) << 8);
3383 #ifdef SAMBA_VERSION_REVISION
3384         extended_info->samba_version |= (tolower(*SAMBA_VERSION_REVISION) - 'a' + 1) & 0xff;
3385 #endif
3386         extended_info->samba_subversion = 0;
3387 #ifdef SAMBA_VERSION_RC_RELEASE
3388         extended_info->samba_subversion |= (SAMBA_VERSION_RC_RELEASE & 0xff) << 24;
3389 #else
3390 #ifdef SAMBA_VERSION_PRE_RELEASE
3391         extended_info->samba_subversion |= (SAMBA_VERSION_PRE_RELEASE & 0xff) << 16;
3392 #endif
3393 #endif
3394 #ifdef SAMBA_VERSION_VENDOR_PATCH
3395         extended_info->samba_subversion |= (SAMBA_VERSION_VENDOR_PATCH & 0xffff);
3396 #endif
3397         extended_info->samba_gitcommitdate = 0;
3398 #ifdef SAMBA_VERSION_COMMIT_TIME
3399         unix_to_nt_time(&extended_info->samba_gitcommitdate, SAMBA_VERSION_COMMIT_TIME);
3400 #endif
3401
3402         memset(extended_info->samba_version_string, 0,
3403                sizeof(extended_info->samba_version_string));
3404
3405         snprintf (extended_info->samba_version_string,
3406                   sizeof(extended_info->samba_version_string),
3407                   "%s", samba_version_string());
3408 }
3409
3410 NTSTATUS smbd_do_qfsinfo(struct smbXsrv_connection *xconn,
3411                          connection_struct *conn,
3412                          TALLOC_CTX *mem_ctx,
3413                          uint16_t info_level,
3414                          uint16_t flags2,
3415                          unsigned int max_data_bytes,
3416                          size_t *fixed_portion,
3417                          struct smb_filename *fname,
3418                          char **ppdata,
3419                          int *ret_data_len)
3420 {
3421         char *pdata, *end_data;
3422         int data_len = 0;
3423         size_t len = 0;
3424         const char *vname = volume_label(talloc_tos(), SNUM(conn));
3425         int snum = SNUM(conn);
3426         const char *fstype = lp_fstype(SNUM(conn));
3427         const char *filename = NULL;
3428         const uint64_t bytes_per_sector = 512;
3429         uint32_t additional_flags = 0;
3430         struct smb_filename smb_fname;
3431         SMB_STRUCT_STAT st;
3432         NTSTATUS status = NT_STATUS_OK;
3433         uint64_t df_ret;
3434
3435         if (fname == NULL || fname->base_name == NULL) {
3436                 filename = ".";
3437         } else {
3438                 filename = fname->base_name;
3439         }
3440
3441         if (IS_IPC(conn)) {
3442                 if (info_level != SMB_QUERY_CIFS_UNIX_INFO) {
3443                         DEBUG(0,("smbd_do_qfsinfo: not an allowed "
3444                                 "info level (0x%x) on IPC$.\n",
3445                                 (unsigned int)info_level));
3446                         return NT_STATUS_ACCESS_DENIED;
3447                 }
3448         }
3449
3450         DEBUG(3,("smbd_do_qfsinfo: level = %d\n", info_level));
3451
3452         ZERO_STRUCT(smb_fname);
3453         smb_fname.base_name = discard_const_p(char, filename);
3454
3455         if(SMB_VFS_STAT(conn, &smb_fname) != 0) {
3456                 DEBUG(2,("stat of . failed (%s)\n", strerror(errno)));
3457                 return map_nt_error_from_unix(errno);
3458         }
3459
3460         st = smb_fname.st;
3461
3462         if (max_data_bytes + DIR_ENTRY_SAFETY_MARGIN < max_data_bytes) {
3463                 return NT_STATUS_INVALID_PARAMETER;
3464         }
3465
3466         *ppdata = (char *)SMB_REALLOC(
3467                 *ppdata, max_data_bytes + DIR_ENTRY_SAFETY_MARGIN);
3468         if (*ppdata == NULL) {
3469                 return NT_STATUS_NO_MEMORY;
3470         }
3471
3472         pdata = *ppdata;
3473         memset((char *)pdata,'\0',max_data_bytes + DIR_ENTRY_SAFETY_MARGIN);
3474         end_data = pdata + max_data_bytes + DIR_ENTRY_SAFETY_MARGIN - 1;
3475
3476         *fixed_portion = 0;
3477
3478         switch (info_level) {
3479                 case SMB_INFO_ALLOCATION:
3480                 {
3481                         uint64_t dfree,dsize,bsize,block_size,sectors_per_unit;
3482                         data_len = 18;
3483                         df_ret = get_dfree_info(conn, &smb_fname, &bsize,
3484                                                 &dfree, &dsize);
3485                         if (df_ret == (uint64_t)-1) {
3486                                 return map_nt_error_from_unix(errno);
3487                         }
3488
3489                         block_size = lp_block_size(snum);
3490                         if (bsize < block_size) {
3491                                 uint64_t factor = block_size/bsize;
3492                                 bsize = block_size;
3493                                 dsize /= factor;
3494                                 dfree /= factor;
3495                         }
3496                         if (bsize > block_size) {
3497                                 uint64_t factor = bsize/block_size;
3498                                 bsize = block_size;
3499                                 dsize *= factor;
3500                                 dfree *= factor;
3501                         }
3502                         sectors_per_unit = bsize/bytes_per_sector;
3503
3504                         DEBUG(5,("smbd_do_qfsinfo : SMB_INFO_ALLOCATION id=%x, bsize=%u, cSectorUnit=%u, \
3505 cBytesSector=%u, cUnitTotal=%u, cUnitAvail=%d\n", (unsigned int)st.st_ex_dev, (unsigned int)bsize, (unsigned int)sectors_per_unit,
3506                                 (unsigned int)bytes_per_sector, (unsigned int)dsize, (unsigned int)dfree));
3507
3508                         /*
3509                          * For large drives, return max values and not modulo.
3510                          */
3511                         dsize = MIN(dsize, UINT32_MAX);
3512                         dfree = MIN(dfree, UINT32_MAX);
3513
3514                         SIVAL(pdata,l1_idFileSystem,st.st_ex_dev);
3515                         SIVAL(pdata,l1_cSectorUnit,sectors_per_unit);
3516                         SIVAL(pdata,l1_cUnit,dsize);
3517                         SIVAL(pdata,l1_cUnitAvail,dfree);
3518                         SSVAL(pdata,l1_cbSector,bytes_per_sector);
3519                         break;
3520                 }
3521
3522                 case SMB_INFO_VOLUME:
3523                         /* Return volume name */
3524                         /*
3525                          * Add volume serial number - hash of a combination of
3526                          * the called hostname and the service name.
3527                          */
3528                         SIVAL(pdata,0,str_checksum(lp_servicename(talloc_tos(), snum)) ^ (str_checksum(get_local_machine_name())<<16) );
3529                         /*
3530                          * Win2k3 and previous mess this up by sending a name length
3531                          * one byte short. I believe only older clients (OS/2 Win9x) use
3532                          * this call so try fixing this by adding a terminating null to
3533                          * the pushed string. The change here was adding the STR_TERMINATE. JRA.
3534                          */
3535                         status = srvstr_push(
3536                                 pdata, flags2,
3537                                 pdata+l2_vol_szVolLabel, vname,
3538                                 PTR_DIFF(end_data, pdata+l2_vol_szVolLabel),
3539                                 STR_NOALIGN|STR_TERMINATE, &len);
3540                         if (!NT_STATUS_IS_OK(status)) {
3541                                 return status;
3542                         }
3543                         SCVAL(pdata,l2_vol_cch,len);
3544                         data_len = l2_vol_szVolLabel + len;
3545                         DEBUG(5,("smbd_do_qfsinfo : time = %x, namelen = %u, name = %s\n",
3546                                  (unsigned)convert_timespec_to_time_t(st.st_ex_ctime),
3547                                  (unsigned)len, vname));
3548                         break;
3549
3550                 case SMB_QUERY_FS_ATTRIBUTE_INFO:
3551                 case SMB_FS_ATTRIBUTE_INFORMATION:
3552
3553                         additional_flags = 0;
3554 #if defined(HAVE_SYS_QUOTAS)
3555                         additional_flags |= FILE_VOLUME_QUOTAS;
3556 #endif
3557
3558                         if(lp_nt_acl_support(SNUM(conn))) {
3559                                 additional_flags |= FILE_PERSISTENT_ACLS;
3560                         }
3561
3562                         /* Capabilities are filled in at connection time through STATVFS call */
3563                         additional_flags |= conn->fs_capabilities;
3564                         additional_flags |= lp_parm_int(conn->params->service,
3565                                                         "share", "fake_fscaps",
3566                                                         0);
3567
3568                         SIVAL(pdata,0,FILE_CASE_PRESERVED_NAMES|FILE_CASE_SENSITIVE_SEARCH|
3569                                 FILE_SUPPORTS_OBJECT_IDS|FILE_UNICODE_ON_DISK|
3570                                 additional_flags); /* FS ATTRIBUTES */
3571
3572                         SIVAL(pdata,4,255); /* Max filename component length */
3573                         /* NOTE! the fstype must *not* be null terminated or win98 won't recognise it
3574                                 and will think we can't do long filenames */
3575                         status = srvstr_push(pdata, flags2, pdata+12, fstype,
3576                                           PTR_DIFF(end_data, pdata+12),
3577                                           STR_UNICODE, &len);
3578                         if (!NT_STATUS_IS_OK(status)) {
3579                                 return status;
3580                         }
3581                         SIVAL(pdata,8,len);
3582                         data_len = 12 + len;
3583                         if (max_data_bytes >= 16 && data_len > max_data_bytes) {
3584                                 /* the client only requested a portion of the
3585                                    file system name */
3586                                 data_len = max_data_bytes;
3587                                 status = STATUS_BUFFER_OVERFLOW;
3588                         }
3589                         *fixed_portion = 16;
3590                         break;
3591
3592                 case SMB_QUERY_FS_LABEL_INFO:
3593                 case SMB_FS_LABEL_INFORMATION:
3594                         status = srvstr_push(pdata, flags2, pdata+4, vname,
3595                                           PTR_DIFF(end_data, pdata+4), 0, &len);
3596                         if (!NT_STATUS_IS_OK(status)) {
3597                                 return status;
3598                         }
3599                         data_len = 4 + len;
3600                         SIVAL(pdata,0,len);
3601                         break;
3602
3603                 case SMB_QUERY_FS_VOLUME_INFO:
3604                 case SMB_FS_VOLUME_INFORMATION:
3605
3606                         /*
3607                          * Add volume serial number - hash of a combination of
3608                          * the called hostname and the service name.
3609                          */
3610                         SIVAL(pdata,8,str_checksum(lp_servicename(talloc_tos(), snum)) ^
3611                                 (str_checksum(get_local_machine_name())<<16));
3612
3613                         /* Max label len is 32 characters. */
3614                         status = srvstr_push(pdata, flags2, pdata+18, vname,
3615                                           PTR_DIFF(end_data, pdata+18),
3616                                           STR_UNICODE, &len);
3617                         if (!NT_STATUS_IS_OK(status)) {
3618                                 return status;
3619                         }
3620                         SIVAL(pdata,12,len);
3621                         data_len = 18+len;
3622
3623                         DEBUG(5,("smbd_do_qfsinfo : SMB_QUERY_FS_VOLUME_INFO namelen = %d, vol=%s serv=%s\n",
3624                                 (int)strlen(vname),vname,
3625                                 lp_servicename(talloc_tos(), snum)));
3626                         if (max_data_bytes >= 24 && data_len > max_data_bytes) {
3627                                 /* the client only requested a portion of the
3628                                    volume label */
3629                                 data_len = max_data_bytes;
3630                                 status = STATUS_BUFFER_OVERFLOW;
3631                         }
3632                         *fixed_portion = 24;
3633                         break;
3634
3635                 case SMB_QUERY_FS_SIZE_INFO:
3636                 case SMB_FS_SIZE_INFORMATION:
3637                 {
3638                         uint64_t dfree,dsize,bsize,block_size,sectors_per_unit;
3639                         data_len = 24;
3640                         df_ret = get_dfree_info(conn, &smb_fname, &bsize,
3641                                                 &dfree, &dsize);
3642                         if (df_ret == (uint64_t)-1) {
3643                                 return map_nt_error_from_unix(errno);
3644                         }
3645                         block_size = lp_block_size(snum);
3646                         if (bsize < block_size) {
3647                                 uint64_t factor = block_size/bsize;
3648                                 bsize = block_size;
3649                                 dsize /= factor;
3650                                 dfree /= factor;
3651                         }
3652                         if (bsize > block_size) {
3653                                 uint64_t factor = bsize/block_size;
3654                                 bsize = block_size;
3655                                 dsize *= factor;
3656                                 dfree *= factor;
3657                         }
3658                         sectors_per_unit = bsize/bytes_per_sector;
3659                         DEBUG(5,("smbd_do_qfsinfo : SMB_QUERY_FS_SIZE_INFO bsize=%u, cSectorUnit=%u, \
3660 cBytesSector=%u, cUnitTotal=%u, cUnitAvail=%d\n", (unsigned int)bsize, (unsigned int)sectors_per_unit,
3661                                 (unsigned int)bytes_per_sector, (unsigned int)dsize, (unsigned int)dfree));
3662                         SBIG_UINT(pdata,0,dsize);
3663                         SBIG_UINT(pdata,8,dfree);
3664                         SIVAL(pdata,16,sectors_per_unit);
3665                         SIVAL(pdata,20,bytes_per_sector);
3666                         *fixed_portion = 24;
3667                         break;
3668                 }
3669
3670                 case SMB_FS_FULL_SIZE_INFORMATION:
3671                 {
3672                         uint64_t dfree,dsize,bsize,block_size,sectors_per_unit;
3673                         data_len = 32;
3674                         df_ret = get_dfree_info(conn, &smb_fname, &bsize,
3675                                                 &dfree, &dsize);
3676                         if (df_ret == (uint64_t)-1) {
3677                                 return map_nt_error_from_unix(errno);
3678                         }
3679                         block_size = lp_block_size(snum);
3680                         if (bsize < block_size) {
3681                                 uint64_t factor = block_size/bsize;
3682                                 bsize = block_size;
3683                                 dsize /= factor;
3684                                 dfree /= factor;
3685                         }
3686                         if (bsize > block_size) {
3687                                 uint64_t factor = bsize/block_size;
3688                                 bsize = block_size;
3689                                 dsize *= factor;
3690                                 dfree *= factor;
3691                         }
3692                         sectors_per_unit = bsize/bytes_per_sector;
3693                         DEBUG(5,("smbd_do_qfsinfo : SMB_QUERY_FS_FULL_SIZE_INFO bsize=%u, cSectorUnit=%u, \
3694 cBytesSector=%u, cUnitTotal=%u, cUnitAvail=%d\n", (unsigned int)bsize, (unsigned int)sectors_per_unit,
3695                                 (unsigned int)bytes_per_sector, (unsigned int)dsize, (unsigned int)dfree));
3696                         SBIG_UINT(pdata,0,dsize); /* Total Allocation units. */
3697                         SBIG_UINT(pdata,8,dfree); /* Caller available allocation units. */
3698                         SBIG_UINT(pdata,16,dfree); /* Actual available allocation units. */
3699                         SIVAL(pdata,24,sectors_per_unit); /* Sectors per allocation unit. */
3700                         SIVAL(pdata,28,bytes_per_sector); /* Bytes per sector. */
3701                         *fixed_portion = 32;
3702                         break;
3703                 }
3704
3705                 case SMB_QUERY_FS_DEVICE_INFO:
3706                 case SMB_FS_DEVICE_INFORMATION:
3707                 {
3708                         uint32_t characteristics = FILE_DEVICE_IS_MOUNTED;
3709
3710                         if (!CAN_WRITE(conn)) {
3711                                 characteristics |= FILE_READ_ONLY_DEVICE;
3712                         }
3713                         data_len = 8;
3714                         SIVAL(pdata,0,FILE_DEVICE_DISK); /* dev type */
3715                         SIVAL(pdata,4,characteristics);
3716                         *fixed_portion = 8;
3717                         break;
3718                 }
3719
3720 #ifdef HAVE_SYS_QUOTAS
3721                 case SMB_FS_QUOTA_INFORMATION:
3722                 /*
3723                  * what we have to send --metze:
3724                  *
3725                  * Unknown1:            24 NULL bytes
3726                  * Soft Quota Treshold: 8 bytes seems like uint64_t or so
3727                  * Hard Quota Limit:    8 bytes seems like uint64_t or so
3728                  * Quota Flags:         2 byte :
3729                  * Unknown3:            6 NULL bytes
3730                  *
3731                  * 48 bytes total
3732                  *
3733                  * details for Quota Flags:
3734                  *
3735                  * 0x0020 Log Limit: log if the user exceeds his Hard Quota
3736                  * 0x0010 Log Warn:  log if the user exceeds his Soft Quota
3737                  * 0x0002 Deny Disk: deny disk access when the user exceeds his Hard Quota
3738                  * 0x0001 Enable Quotas: enable quota for this fs
3739                  *
3740                  */
3741                 {
3742                         /* we need to fake up a fsp here,
3743                          * because its not send in this call
3744                          */
3745                         files_struct fsp;
3746                         SMB_NTQUOTA_STRUCT quotas;
3747
3748                         ZERO_STRUCT(fsp);
3749                         ZERO_STRUCT(quotas);
3750
3751                         fsp.conn = conn;
3752                         fsp.fnum = FNUM_FIELD_INVALID;
3753
3754                         /* access check */
3755                         if (get_current_uid(conn) != 0) {
3756                                 DEBUG(0,("get_user_quota: access_denied "
3757                                          "service [%s] user [%s]\n",
3758                                          lp_servicename(talloc_tos(), SNUM(conn)),
3759                                          conn->session_info->unix_info->unix_name));
3760                                 return NT_STATUS_ACCESS_DENIED;
3761                         }
3762
3763                         status = vfs_get_ntquota(&fsp, SMB_USER_FS_QUOTA_TYPE,
3764                                                  NULL, &quotas);
3765                         if (!NT_STATUS_IS_OK(status)) {
3766                                 DEBUG(0,("vfs_get_ntquota() failed for service [%s]\n",lp_servicename(talloc_tos(), SNUM(conn))));
3767                                 return status;
3768                         }
3769
3770                         data_len = 48;
3771
3772                         DEBUG(10,("SMB_FS_QUOTA_INFORMATION: for service [%s]\n",
3773                                   lp_servicename(talloc_tos(), SNUM(conn))));
3774
3775                         /* Unknown1 24 NULL bytes*/
3776                         SBIG_UINT(pdata,0,(uint64_t)0);
3777                         SBIG_UINT(pdata,8,(uint64_t)0);
3778                         SBIG_UINT(pdata,16,(uint64_t)0);
3779
3780                         /* Default Soft Quota 8 bytes */
3781                         SBIG_UINT(pdata,24,quotas.softlim);
3782
3783                         /* Default Hard Quota 8 bytes */
3784                         SBIG_UINT(pdata,32,quotas.hardlim);
3785
3786                         /* Quota flag 2 bytes */
3787                         SSVAL(pdata,40,quotas.qflags);
3788
3789                         /* Unknown3 6 NULL bytes */
3790                         SSVAL(pdata,42,0);
3791                         SIVAL(pdata,44,0);
3792
3793                         break;
3794                 }
3795 #endif /* HAVE_SYS_QUOTAS */
3796                 case SMB_FS_OBJECTID_INFORMATION:
3797                 {
3798                         unsigned char objid[16];
3799                         struct smb_extended_info extended_info;
3800                         memcpy(pdata,create_volume_objectid(conn, objid),16);
3801                         samba_extended_info_version (&extended_info);
3802                         SIVAL(pdata,16,extended_info.samba_magic);
3803                         SIVAL(pdata,20,extended_info.samba_version);
3804                         SIVAL(pdata,24,extended_info.samba_subversion);
3805                         SBIG_UINT(pdata,28,extended_info.samba_gitcommitdate);
3806                         memcpy(pdata+36,extended_info.samba_version_string,28);
3807                         data_len = 64;
3808                         break;
3809                 }
3810
3811                 case SMB_FS_SECTOR_SIZE_INFORMATION:
3812                 {
3813                         data_len = 28;
3814                         /*
3815                          * These values match a physical Windows Server 2012
3816                          * share backed by NTFS atop spinning rust.
3817                          */
3818                         DEBUG(5, ("SMB_FS_SECTOR_SIZE_INFORMATION:"));
3819                         /* logical_bytes_per_sector */
3820                         SIVAL(pdata, 0, bytes_per_sector);
3821                         /* phys_bytes_per_sector_atomic */
3822                         SIVAL(pdata, 4, bytes_per_sector);
3823                         /* phys_bytes_per_sector_perf */
3824                         SIVAL(pdata, 8, bytes_per_sector);
3825                         /* fs_effective_phys_bytes_per_sector_atomic */
3826                         SIVAL(pdata, 12, bytes_per_sector);
3827                         /* flags */
3828                         SIVAL(pdata, 16, SSINFO_FLAGS_ALIGNED_DEVICE
3829                                 | SSINFO_FLAGS_PARTITION_ALIGNED_ON_DEVICE);
3830                         /* byte_off_sector_align */
3831                         SIVAL(pdata, 20, 0);
3832                         /* byte_off_partition_align */
3833                         SIVAL(pdata, 24, 0);
3834                         *fixed_portion = 28;
3835                         break;
3836                 }
3837
3838
3839                 /*
3840                  * Query the version and capabilities of the CIFS UNIX extensions
3841                  * in use.
3842                  */
3843
3844                 case SMB_QUERY_CIFS_UNIX_INFO:
3845                 {
3846                         bool large_write = lp_min_receive_file_size() &&
3847                                         !srv_is_signing_active(xconn);
3848                         bool large_read = !srv_is_signing_active(xconn);
3849                         int encrypt_caps = 0;
3850
3851                         if (!lp_unix_extensions()) {
3852                                 return NT_STATUS_INVALID_LEVEL;
3853                         }
3854
3855                         switch (conn->encrypt_level) {
3856                         case SMB_SIGNING_OFF:
3857                                 encrypt_caps = 0;
3858                                 break;
3859                         case SMB_SIGNING_DESIRED:
3860                         case SMB_SIGNING_IF_REQUIRED:
3861                         case SMB_SIGNING_DEFAULT:
3862                                 encrypt_caps = CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP;
3863                                 break;
3864                         case SMB_SIGNING_REQUIRED:
3865                                 encrypt_caps = CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP|
3866                                                 CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP;
3867                                 large_write = false;
3868                                 large_read = false;
3869                                 break;
3870                         }
3871
3872                         data_len = 12;
3873                         SSVAL(pdata,0,CIFS_UNIX_MAJOR_VERSION);
3874                         SSVAL(pdata,2,CIFS_UNIX_MINOR_VERSION);
3875
3876                         /* We have POSIX ACLs, pathname, encryption,
3877                          * large read/write, and locking capability. */
3878
3879                         SBIG_UINT(pdata,4,((uint64_t)(
3880                                         CIFS_UNIX_POSIX_ACLS_CAP|
3881                                         CIFS_UNIX_POSIX_PATHNAMES_CAP|
3882                                         CIFS_UNIX_FCNTL_LOCKS_CAP|
3883                                         CIFS_UNIX_EXTATTR_CAP|
3884                                         CIFS_UNIX_POSIX_PATH_OPERATIONS_CAP|
3885                                         encrypt_caps|
3886                                         (large_read ? CIFS_UNIX_LARGE_READ_CAP : 0) |
3887                                         (large_write ?
3888                                         CIFS_UNIX_LARGE_WRITE_CAP : 0))));
3889                         break;
3890                 }
3891
3892                 case SMB_QUERY_POSIX_FS_INFO:
3893                 {
3894                         int rc;
3895                         vfs_statvfs_struct svfs;
3896
3897                         if (!lp_unix_extensions()) {
3898                                 return NT_STATUS_INVALID_LEVEL;
3899                         }
3900
3901                         rc = SMB_VFS_STATVFS(conn, &smb_fname, &svfs);
3902
3903                         if (!rc) {
3904                                 data_len = 56;
3905                                 SIVAL(pdata,0,svfs.OptimalTransferSize);
3906                                 SIVAL(pdata,4,svfs.BlockSize);
3907                                 SBIG_UINT(pdata,8,svfs.TotalBlocks);
3908                                 SBIG_UINT(pdata,16,svfs.BlocksAvail);
3909                                 SBIG_UINT(pdata,24,svfs.UserBlocksAvail);
3910                                 SBIG_UINT(pdata,32,svfs.TotalFileNodes);
3911                                 SBIG_UINT(pdata,40,svfs.FreeFileNodes);
3912                                 SBIG_UINT(pdata,48,svfs.FsIdentifier);
3913                                 DEBUG(5,("smbd_do_qfsinfo : SMB_QUERY_POSIX_FS_INFO succsessful\n"));
3914 #ifdef EOPNOTSUPP
3915                         } else if (rc == EOPNOTSUPP) {
3916                                 return NT_STATUS_INVALID_LEVEL;
3917 #endif /* EOPNOTSUPP */
3918                         } else {
3919                                 DEBUG(0,("vfs_statvfs() failed for service [%s]\n",lp_servicename(talloc_tos(), SNUM(conn))));
3920                                 return NT_STATUS_DOS(ERRSRV, ERRerror);
3921                         }
3922                         break;
3923                 }
3924
3925                 case SMB_QUERY_POSIX_WHOAMI:
3926                 {
3927                         uint32_t flags = 0;
3928                         uint32_t sid_bytes;
3929                         int i;
3930
3931                         if (!lp_unix_extensions()) {
3932                                 return NT_STATUS_INVALID_LEVEL;
3933                         }
3934
3935                         if (max_data_bytes < 40) {
3936                                 return NT_STATUS_BUFFER_TOO_SMALL;
3937                         }
3938
3939                         if (security_session_user_level(conn->session_info, NULL) < SECURITY_USER) {
3940                                 flags |= SMB_WHOAMI_GUEST;
3941                         }
3942
3943                         /* NOTE: 8 bytes for UID/GID, irrespective of native
3944                          * platform size. This matches
3945                          * SMB_QUERY_FILE_UNIX_BASIC and friends.
3946                          */
3947                         data_len = 4 /* flags */
3948                             + 4 /* flag mask */
3949                             + 8 /* uid */
3950                             + 8 /* gid */
3951                             + 4 /* ngroups */
3952                             + 4 /* num_sids */
3953                             + 4 /* SID bytes */
3954                             + 4 /* pad/reserved */
3955                             + (conn->session_info->unix_token->ngroups * 8)
3956                                 /* groups list */
3957                             + (conn->session_info->security_token->num_sids *
3958                                     SID_MAX_SIZE)
3959                                 /* SID list */;
3960
3961                         SIVAL(pdata, 0, flags);
3962                         SIVAL(pdata, 4, SMB_WHOAMI_MASK);
3963                         SBIG_UINT(pdata, 8,
3964                                   (uint64_t)conn->session_info->unix_token->uid);
3965                         SBIG_UINT(pdata, 16,
3966                                   (uint64_t)conn->session_info->unix_token->gid);
3967
3968
3969                         if (data_len >= max_data_bytes) {
3970                                 /* Potential overflow, skip the GIDs and SIDs. */
3971
3972                                 SIVAL(pdata, 24, 0); /* num_groups */
3973                                 SIVAL(pdata, 28, 0); /* num_sids */
3974                                 SIVAL(pdata, 32, 0); /* num_sid_bytes */
3975                                 SIVAL(pdata, 36, 0); /* reserved */
3976
3977                                 data_len = 40;
3978                                 break;
3979                         }
3980
3981                         SIVAL(pdata, 24, conn->session_info->unix_token->ngroups);
3982                         SIVAL(pdata, 28, conn->session_info->security_token->num_sids);
3983
3984                         /* We walk the SID list twice, but this call is fairly
3985                          * infrequent, and I don't expect that it's performance
3986                          * sensitive -- jpeach
3987                          */
3988                         for (i = 0, sid_bytes = 0;
3989                              i < conn->session_info->security_token->num_sids; ++i) {
3990                                 sid_bytes += ndr_size_dom_sid(
3991                                         &conn->session_info->security_token->sids[i],
3992                                         0);
3993                         }
3994
3995                         /* SID list byte count */
3996                         SIVAL(pdata, 32, sid_bytes);
3997
3998                         /* 4 bytes pad/reserved - must be zero */
3999                         SIVAL(pdata, 36, 0);
4000                         data_len = 40;
4001
4002                         /* GID list */
4003                         for (i = 0; i < conn->session_info->unix_token->ngroups; ++i) {
4004                                 SBIG_UINT(pdata, data_len,
4005                                           (uint64_t)conn->session_info->unix_token->groups[i]);
4006                                 data_len += 8;
4007                         }
4008
4009                         /* SID list */
4010                         for (i = 0;
4011                             i < conn->session_info->security_token->num_sids; ++i) {
4012                                 int sid_len = ndr_size_dom_sid(
4013                                         &conn->session_info->security_token->sids[i],
4014                                         0);
4015
4016                                 sid_linearize((uint8_t *)(pdata + data_len),
4017                                               sid_len,
4018                                     &conn->session_info->security_token->sids[i]);
4019                                 data_len += sid_len;
4020                         }
4021
4022                         break;
4023                 }
4024
4025                 case SMB_MAC_QUERY_FS_INFO:
4026                         /*
4027                          * Thursby MAC extension... ONLY on NTFS filesystems
4028                          * once we do streams then we don't need this
4029                          */
4030                         if (strequal(lp_fstype(SNUM(conn)),"NTFS")) {
4031                                 data_len = 88;
4032                                 SIVAL(pdata,84,0x100); /* Don't support mac... */
4033                                 break;
4034                         }
4035                         /* drop through */
4036                 default:
4037                         return NT_STATUS_INVALID_LEVEL;
4038         }
4039
4040         *ret_data_len = data_len;
4041         return status;
4042 }
4043
4044 static NTSTATUS smb_set_fsquota(connection_struct *conn,
4045                         struct smb_request *req,
4046                         files_struct *fsp,
4047                         const DATA_BLOB *qdata)
4048 {
4049         NTSTATUS status;
4050         SMB_NTQUOTA_STRUCT quotas;
4051
4052         ZERO_STRUCT(quotas);
4053
4054         /* access check */
4055         if ((get_current_uid(conn) != 0) || !CAN_WRITE(conn)) {
4056                 DEBUG(3, ("set_fsquota: access_denied service [%s] user [%s]\n",
4057                           lp_servicename(talloc_tos(), SNUM(conn)),
4058                           conn->session_info->unix_info->unix_name));
4059                 return NT_STATUS_ACCESS_DENIED;
4060         }
4061
4062         if (!check_fsp_ntquota_handle(conn, req,
4063                                       fsp)) {
4064                 DEBUG(1, ("set_fsquota: no valid QUOTA HANDLE\n"));
4065                 return NT_STATUS_INVALID_HANDLE;
4066         }
4067
4068         /* note: normally there're 48 bytes,
4069          * but we didn't use the last 6 bytes for now
4070          * --metze
4071          */
4072         if (qdata->length < 42) {
4073                 DEBUG(0,("set_fsquota: requires total_data(%u) >= 42 bytes!\n",
4074                         (unsigned int)qdata->length));
4075                 return NT_STATUS_INVALID_PARAMETER;
4076         }
4077
4078         /* unknown_1 24 NULL bytes in pdata*/
4079
4080         /* the soft quotas 8 bytes (uint64_t)*/
4081         quotas.softlim = BVAL(qdata->data,24);
4082
4083         /* the hard quotas 8 bytes (uint64_t)*/
4084         quotas.hardlim = BVAL(qdata->data,32);
4085
4086         /* quota_flags 2 bytes **/
4087         quotas.qflags = SVAL(qdata->data,40);
4088
4089         /* unknown_2 6 NULL bytes follow*/
4090
4091         /* now set the quotas */
4092         if (vfs_set_ntquota(fsp, SMB_USER_FS_QUOTA_TYPE, NULL, &quotas)!=0) {
4093                 DEBUG(1, ("vfs_set_ntquota() failed for service [%s]\n",
4094                           lp_servicename(talloc_tos(), SNUM(conn))));
4095                 status =  map_nt_error_from_unix(errno);
4096         } else {
4097                 status = NT_STATUS_OK;
4098         }
4099         return status;
4100 }
4101
4102 NTSTATUS smbd_do_setfsinfo(connection_struct *conn,
4103                                 struct smb_request *req,
4104                                 TALLOC_CTX *mem_ctx,
4105                                 uint16_t info_level,
4106                                 files_struct *fsp,
4107                                 const DATA_BLOB *pdata)
4108 {
4109         switch (info_level) {
4110                 case SMB_FS_QUOTA_INFORMATION:
4111                 {
4112                         return smb_set_fsquota(conn,
4113                                                 req,
4114                                                 fsp,
4115                                                 pdata);
4116                 }
4117
4118                 default:
4119                         break;
4120         }
4121         return NT_STATUS_INVALID_LEVEL;
4122 }
4123
4124 /****************************************************************************
4125  Reply to a TRANS2_QFSINFO (query filesystem info).
4126 ****************************************************************************/
4127
4128 static void call_trans2qfsinfo(connection_struct *conn,
4129                                struct smb_request *req,
4130                                char **pparams, int total_params,
4131                                char **ppdata, int total_data,
4132                                unsigned int max_data_bytes)
4133 {
4134         char *params = *pparams;
4135         uint16_t info_level;
4136         int data_len = 0;
4137         size_t fixed_portion;
4138         NTSTATUS status;
4139
4140         if (total_params < 2) {
4141                 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
4142                 return;
4143         }
4144
4145         info_level = SVAL(params,0);
4146
4147         if (ENCRYPTION_REQUIRED(conn) && !req->encrypted) {
4148                 if (info_level != SMB_QUERY_CIFS_UNIX_INFO) {
4149                         DEBUG(0,("call_trans2qfsinfo: encryption required "
4150                                 "and info level 0x%x sent.\n",
4151                                 (unsigned int)info_level));
4152                         reply_nterror(req, NT_STATUS_ACCESS_DENIED);
4153                         return;
4154                 }
4155         }
4156
4157         DEBUG(3,("call_trans2qfsinfo: level = %d\n", info_level));
4158
4159         status = smbd_do_qfsinfo(req->xconn, conn, req,
4160                                  info_level,
4161                                  req->flags2,
4162                                  max_data_bytes,
4163                                  &fixed_portion,
4164                                  NULL,
4165                                  ppdata, &data_len);
4166         if (!NT_STATUS_IS_OK(status)) {
4167                 reply_nterror(req, status);
4168                 return;
4169         }
4170
4171         send_trans2_replies(conn, req, NT_STATUS_OK, params, 0, *ppdata, data_len,
4172                             max_data_bytes);
4173
4174         DEBUG( 4, ( "%s info_level = %d\n",
4175                     smb_fn_name(req->cmd), info_level) );
4176
4177         return;
4178 }
4179
4180 /****************************************************************************
4181  Reply to a TRANS2_SETFSINFO (set filesystem info).
4182 ****************************************************************************/
4183
4184 static void call_trans2setfsinfo(connection_struct *conn,
4185                                  struct smb_request *req,
4186                                  char **pparams, int total_params,
4187                                  char **ppdata, int total_data,
4188                                  unsigned int max_data_bytes)
4189 {
4190         struct smbXsrv_connection *xconn = req->xconn;
4191         char *pdata = *ppdata;
4192         char *params = *pparams;
4193         uint16_t info_level;
4194
4195         DEBUG(10,("call_trans2setfsinfo: for service [%s]\n",
4196                   lp_servicename(talloc_tos(), SNUM(conn))));
4197
4198         /*  */
4199         if (total_params < 4) {
4200                 DEBUG(0,("call_trans2setfsinfo: requires total_params(%d) >= 4 bytes!\n",
4201                         total_params));
4202                 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
4203                 return;
4204         }
4205
4206         info_level = SVAL(params,2);
4207
4208         if (IS_IPC(conn)) {
4209                 if (info_level != SMB_REQUEST_TRANSPORT_ENCRYPTION &&
4210                                 info_level != SMB_SET_CIFS_UNIX_INFO) {
4211                         DEBUG(0,("call_trans2setfsinfo: not an allowed "
4212                                 "info level (0x%x) on IPC$.\n",
4213                                 (unsigned int)info_level));
4214                         reply_nterror(req, NT_STATUS_ACCESS_DENIED);
4215                         return;
4216                 }
4217         }
4218
4219         if (ENCRYPTION_REQUIRED(conn) && !req->encrypted) {
4220                 if (info_level != SMB_REQUEST_TRANSPORT_ENCRYPTION) {
4221                         DEBUG(0,("call_trans2setfsinfo: encryption required "
4222                                 "and info level 0x%x sent.\n",
4223                                 (unsigned int)info_level));
4224                         reply_nterror(req, NT_STATUS_ACCESS_DENIED);
4225                         return;
4226                 }
4227         }
4228
4229         switch(info_level) {
4230                 case SMB_SET_CIFS_UNIX_INFO:
4231                         if (!lp_unix_extensions()) {
4232                                 DEBUG(2,("call_trans2setfsinfo: "
4233                                         "SMB_SET_CIFS_UNIX_INFO is invalid with "
4234                                         "unix extensions off\n"));
4235                                 reply_nterror(req,
4236                                               NT_STATUS_INVALID_LEVEL);
4237                                 return;
4238                         }
4239
4240                         /* There should be 12 bytes of capabilities set. */
4241                         if (total_data < 12) {
4242                                 reply_nterror(
4243                                         req,
4244                                         NT_STATUS_INVALID_PARAMETER);
4245                                 return;
4246                         }
4247                         xconn->smb1.unix_info.client_major = SVAL(pdata,0);
4248                         xconn->smb1.unix_info.client_minor = SVAL(pdata,2);
4249                         xconn->smb1.unix_info.client_cap_low = IVAL(pdata,4);
4250                         xconn->smb1.unix_info.client_cap_high = IVAL(pdata,8);
4251                         /* Just print these values for now. */
4252                         DEBUG(10, ("call_trans2setfsinfo: set unix_info info. "
4253                                    "major = %u, minor = %u cap_low = 0x%x, "
4254                                    "cap_high = 0x%xn",
4255                                    (unsigned int)xconn->
4256                                    smb1.unix_info.client_major,
4257                                    (unsigned int)xconn->
4258                                    smb1.unix_info.client_minor,
4259                                    (unsigned int)xconn->
4260                                    smb1.unix_info.client_cap_low,
4261                                    (unsigned int)xconn->
4262                                    smb1.unix_info.client_cap_high));
4263
4264                         /* Here is where we must switch to posix pathname processing... */
4265                         if (xconn->smb1.unix_info.client_cap_low & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
4266                                 lp_set_posix_pathnames();
4267                                 mangle_change_to_posix();
4268                         }
4269
4270                         if ((xconn->smb1.unix_info.client_cap_low & CIFS_UNIX_FCNTL_LOCKS_CAP) &&
4271                             !(xconn->smb1.unix_info.client_cap_low & CIFS_UNIX_POSIX_PATH_OPERATIONS_CAP)) {
4272                                 /* Client that knows how to do posix locks,
4273                                  * but not posix open/mkdir operations. Set a
4274                                  * default type for read/write checks. */
4275
4276                                 lp_set_posix_default_cifsx_readwrite_locktype(POSIX_LOCK);
4277
4278                         }
4279                         break;
4280
4281                 case SMB_REQUEST_TRANSPORT_ENCRYPTION:
4282                         {
4283                                 NTSTATUS status;
4284                                 size_t param_len = 0;
4285                                 size_t data_len = total_data;
4286
4287                                 if (!lp_unix_extensions()) {
4288                                         reply_nterror(
4289                                                 req,
4290                                                 NT_STATUS_INVALID_LEVEL);
4291                                         return;
4292                                 }
4293
4294                                 if (lp_smb_encrypt(SNUM(conn)) == SMB_SIGNING_OFF) {
4295                                         reply_nterror(
4296                                                 req,
4297                                                 NT_STATUS_NOT_SUPPORTED);
4298                                         return;
4299                                 }
4300
4301                                 if (xconn->smb1.echo_handler.trusted_fde) {
4302                                         DEBUG( 2,("call_trans2setfsinfo: "
4303                                                 "request transport encryption disabled"
4304                                                 "with 'fork echo handler = yes'\n"));
4305                                         reply_nterror(
4306                                                 req,
4307                                                 NT_STATUS_NOT_SUPPORTED);
4308                                         return;
4309                                 }
4310
4311                                 DEBUG( 4,("call_trans2setfsinfo: "
4312                                         "request transport encryption.\n"));
4313
4314                                 status = srv_request_encryption_setup(conn,
4315                                                                 (unsigned char **)ppdata,
4316                                                                 &data_len,
4317                                                                 (unsigned char **)pparams,
4318                                                                 &param_len);
4319
4320                                 if (!NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED) &&
4321                                                 !NT_STATUS_IS_OK(status)) {
4322                                         reply_nterror(req, status);
4323                                         return;
4324                                 }
4325
4326                                 send_trans2_replies(conn, req,
4327                                                 NT_STATUS_OK,
4328                                                 *pparams,
4329                                                 param_len,
4330                                                 *ppdata,
4331                                                 data_len,
4332                                                 max_data_bytes);
4333
4334                                 if (NT_STATUS_IS_OK(status)) {
4335                                         /* Server-side transport
4336                                          * encryption is now *on*. */
4337                                         status = srv_encryption_start(conn);
4338                                         if (!NT_STATUS_IS_OK(status)) {
4339                                                 char *reason = talloc_asprintf(talloc_tos(),
4340                                                                                "Failure in setting "
4341                                                                                "up encrypted transport: %s",
4342                                                                                nt_errstr(status));
4343                                                 exit_server_cleanly(reason);
4344                                         }
4345                                 }
4346                                 return;
4347                         }
4348
4349                 case SMB_FS_QUOTA_INFORMATION:
4350                         {
4351                                 NTSTATUS status;
4352                                 DATA_BLOB qdata = {
4353                                                 .data = (uint8_t *)pdata,
4354                                                 .length = total_data
4355                                 };
4356                                 files_struct *fsp = NULL;
4357                                 fsp = file_fsp(req, SVAL(params,0));
4358
4359                                 status = smb_set_fsquota(conn,
4360                                                         req,
4361                                                         fsp,
4362                                                         &qdata);
4363                                 if (!NT_STATUS_IS_OK(status)) {
4364                                         reply_nterror(req, status);
4365                                         return;
4366                                 }
4367                                 break;
4368                         }
4369                 default:
4370                         DEBUG(3,("call_trans2setfsinfo: unknown level (0x%X) not implemented yet.\n",
4371                                 info_level));
4372                         reply_nterror(req, NT_STATUS_INVALID_LEVEL);
4373                         return;
4374                         break;
4375         }
4376
4377         /*
4378          * sending this reply works fine,
4379          * but I'm not sure it's the same
4380          * like windows do...
4381          * --metze
4382          */
4383         reply_outbuf(req, 10, 0);
4384 }
4385
4386 #if defined(HAVE_POSIX_ACLS)
4387 /****************************************************************************
4388  Utility function to count the number of entries in a POSIX acl.
4389 ****************************************************************************/
4390
4391 static unsigned int count_acl_entries(connection_struct *conn, SMB_ACL_T posix_acl)
4392 {
4393         unsigned int ace_count = 0;
4394         int entry_id = SMB_ACL_FIRST_ENTRY;
4395         SMB_ACL_ENTRY_T entry;
4396
4397         while ( posix_acl && (sys_acl_get_entry(posix_acl, entry_id, &entry) == 1)) {
4398                 /* get_next... */
4399                 if (entry_id == SMB_ACL_FIRST_ENTRY) {
4400                         entry_id = SMB_ACL_NEXT_ENTRY;
4401                 }
4402                 ace_count++;
4403         }
4404         return ace_count;
4405 }
4406
4407 /****************************************************************************
4408  Utility function to marshall a POSIX acl into wire format.
4409 ****************************************************************************/
4410
4411 static bool marshall_posix_acl(connection_struct *conn, char *pdata, SMB_STRUCT_STAT *pst, SMB_ACL_T posix_acl)
4412 {
4413         int entry_id = SMB_ACL_FIRST_ENTRY;
4414         SMB_ACL_ENTRY_T entry;
4415
4416         while ( posix_acl && (sys_acl_get_entry(posix_acl, entry_id, &entry) == 1)) {
4417                 SMB_ACL_TAG_T tagtype;
4418                 SMB_ACL_PERMSET_T permset;
4419                 unsigned char perms = 0;
4420                 unsigned int own_grp;
4421
4422                 /* get_next... */
4423                 if (entry_id == SMB_ACL_FIRST_ENTRY) {
4424                         entry_id = SMB_ACL_NEXT_ENTRY;
4425                 }
4426
4427                 if (sys_acl_get_tag_type(entry, &tagtype) == -1) {
4428                         DEBUG(0,("marshall_posix_acl: SMB_VFS_SYS_ACL_GET_TAG_TYPE failed.\n"));
4429                         return False;
4430                 }
4431
4432                 if (sys_acl_get_permset(entry, &permset) == -1) {
4433                         DEBUG(0,("marshall_posix_acl: SMB_VFS_SYS_ACL_GET_PERMSET failed.\n"));
4434                         return False;
4435                 }
4436
4437                 perms |= (sys_acl_get_perm(permset, SMB_ACL_READ) ? SMB_POSIX_ACL_READ : 0);
4438                 perms |= (sys_acl_get_perm(permset, SMB_ACL_WRITE) ? SMB_POSIX_ACL_WRITE : 0);
4439                 perms |= (sys_acl_get_perm(permset, SMB_ACL_EXECUTE) ? SMB_POSIX_ACL_EXECUTE : 0);
4440
4441                 SCVAL(pdata,1,perms);
4442
4443                 switch (tagtype) {
4444                         case SMB_ACL_USER_OBJ:
4445                                 SCVAL(pdata,0,SMB_POSIX_ACL_USER_OBJ);
4446                                 own_grp = (unsigned int)pst->st_ex_uid;
4447                                 SIVAL(pdata,2,own_grp);
4448                                 SIVAL(pdata,6,0);
4449                                 break;
4450                         case SMB_ACL_USER:
4451                                 {
4452                                         uid_t *puid = (uid_t *)sys_acl_get_qualifier(entry);
4453                                         if (!puid) {
4454                                                 DEBUG(0,("marshall_posix_acl: SMB_VFS_SYS_ACL_GET_QUALIFIER failed.\n"));
4455                                                 return False;
4456                                         }
4457                                         own_grp = (unsigned int)*puid;
4458                                         SCVAL(pdata,0,SMB_POSIX_ACL_USER);
4459                                         SIVAL(pdata,2,own_grp);
4460                                         SIVAL(pdata,6,0);
4461                                         break;
4462                                 }
4463                         case SMB_ACL_GROUP_OBJ:
4464                                 SCVAL(pdata,0,SMB_POSIX_ACL_GROUP_OBJ);
4465                                 own_grp = (unsigned int)pst->st_ex_gid;
4466                                 SIVAL(pdata,2,own_grp);
4467                                 SIVAL(pdata,6,0);
4468                                 break;
4469                         case SMB_ACL_GROUP:
4470                                 {
4471                                         gid_t *pgid= (gid_t *)sys_acl_get_qualifier(entry);
4472                                         if (!pgid) {
4473                                                 DEBUG(0,("marshall_posix_acl: SMB_VFS_SYS_ACL_GET_QUALIFIER failed.\n"));
4474                                                 return False;
4475                                         }
4476                                         own_grp = (unsigned int)*pgid;
4477                                         SCVAL(pdata,0,SMB_POSIX_ACL_GROUP);
4478                                         SIVAL(pdata,2,own_grp);
4479                                         SIVAL(pdata,6,0);
4480                                         break;
4481                                 }
4482                         case SMB_ACL_MASK:
4483                                 SCVAL(pdata,0,SMB_POSIX_ACL_MASK);
4484                                 SIVAL(pdata,2,0xFFFFFFFF);
4485                                 SIVAL(pdata,6,0xFFFFFFFF);
4486                                 break;
4487                         case SMB_ACL_OTHER:
4488                                 SCVAL(pdata,0,SMB_POSIX_ACL_OTHER);
4489                                 SIVAL(pdata,2,0xFFFFFFFF);
4490                                 SIVAL(pdata,6,0xFFFFFFFF);
4491                                 break;
4492                         default:
4493                                 DEBUG(0,("marshall_posix_acl: unknown tagtype.\n"));
4494                                 return False;
4495                 }
4496                 pdata += SMB_POSIX_ACL_ENTRY_SIZE;
4497         }
4498
4499         return True;
4500 }
4501 #endif
4502
4503 /****************************************************************************
4504  Store the FILE_UNIX_BASIC info.
4505 ****************************************************************************/
4506
4507 static char *store_file_unix_basic(connection_struct *conn,
4508                                 char *pdata,
4509                                 files_struct *fsp,
4510                                 const SMB_STRUCT_STAT *psbuf)
4511 {
4512         uint64_t file_index = get_FileIndex(conn, psbuf);
4513         dev_t devno;
4514
4515         DEBUG(10,("store_file_unix_basic: SMB_QUERY_FILE_UNIX_BASIC\n"));
4516         DEBUG(4,("store_file_unix_basic: st_mode=%o\n",(int)psbuf->st_ex_mode));
4517
4518         SOFF_T(pdata,0,get_file_size_stat(psbuf));             /* File size 64 Bit */
4519         pdata += 8;
4520
4521         SOFF_T(pdata,0,SMB_VFS_GET_ALLOC_SIZE(conn,fsp,psbuf)); /* Number of bytes used on disk - 64 Bit */
4522         pdata += 8;
4523
4524         put_long_date_timespec(TIMESTAMP_SET_NT_OR_BETTER, pdata, psbuf->st_ex_ctime);       /* Change Time 64 Bit */
4525         put_long_date_timespec(TIMESTAMP_SET_NT_OR_BETTER ,pdata+8, psbuf->st_ex_atime);     /* Last access time 64 Bit */
4526         put_long_date_timespec(TIMESTAMP_SET_NT_OR_BETTER, pdata+16, psbuf->st_ex_mtime);    /* Last modification time 64 Bit */
4527         pdata += 24;
4528
4529         SIVAL(pdata,0,psbuf->st_ex_uid);               /* user id for the owner */
4530         SIVAL(pdata,4,0);
4531         pdata += 8;
4532
4533         SIVAL(pdata,0,psbuf->st_ex_gid);               /* group id of owner */
4534         SIVAL(pdata,4,0);
4535         pdata += 8;
4536
4537         SIVAL(pdata,0,unix_filetype(psbuf->st_ex_mode));
4538         pdata += 4;
4539
4540         if (S_ISBLK(psbuf->st_ex_mode) || S_ISCHR(psbuf->st_ex_mode)) {
4541                 devno = psbuf->st_ex_rdev;
4542         } else {
4543                 devno = psbuf->st_ex_dev;
4544         }
4545
4546         SIVAL(pdata,0,unix_dev_major(devno));   /* Major device number if type is device */
4547         SIVAL(pdata,4,0);
4548         pdata += 8;
4549
4550         SIVAL(pdata,0,unix_dev_minor(devno));   /* Minor device number if type is device */
4551         SIVAL(pdata,4,0);
4552         pdata += 8;
4553
4554         SINO_T_VAL(pdata,0,(SMB_INO_T)file_index);   /* inode number */
4555         pdata += 8;
4556
4557         SIVAL(pdata,0, unix_perms_to_wire(psbuf->st_ex_mode));     /* Standard UNIX file permissions */
4558         SIVAL(pdata,4,0);
4559         pdata += 8;
4560
4561         SIVAL(pdata,0,psbuf->st_ex_nlink);             /* number of hard links */
4562         SIVAL(pdata,4,0);
4563         pdata += 8;
4564
4565         return pdata;
4566 }
4567
4568 /* Forward and reverse mappings from the UNIX_INFO2 file flags field and
4569  * the chflags(2) (or equivalent) flags.
4570  *
4571  * XXX: this really should be behind the VFS interface. To do this, we would
4572  * need to alter SMB_STRUCT_STAT so that it included a flags and a mask field.
4573  * Each VFS module could then implement its own mapping as appropriate for the
4574  * platform. We would then pass the SMB flags into SMB_VFS_CHFLAGS.
4575  */
4576 static const struct {unsigned stat_fflag; unsigned smb_fflag;}
4577         info2_flags_map[] =
4578 {
4579 #ifdef UF_NODUMP
4580     { UF_NODUMP, EXT_DO_NOT_BACKUP },
4581 #endif
4582
4583 #ifdef UF_IMMUTABLE
4584     { UF_IMMUTABLE, EXT_IMMUTABLE },
4585 #endif
4586
4587 #ifdef UF_APPEND
4588     { UF_APPEND, EXT_OPEN_APPEND_ONLY },
4589 #endif
4590
4591 #ifdef UF_HIDDEN
4592     { UF_HIDDEN, EXT_HIDDEN },
4593 #endif
4594
4595     /* Do not remove. We need to guarantee that this array has at least one
4596      * entry to build on HP-UX.
4597      */
4598     { 0, 0 }
4599
4600 };
4601
4602 static void map_info2_flags_from_sbuf(const SMB_STRUCT_STAT *psbuf,
4603                                 uint32_t *smb_fflags, uint32_t *smb_fmask)
4604 {
4605         int i;
4606
4607         for (i = 0; i < ARRAY_SIZE(info2_flags_map); ++i) {
4608             *smb_fmask |= info2_flags_map[i].smb_fflag;
4609             if (psbuf->st_ex_flags & info2_flags_map[i].stat_fflag) {
4610                     *smb_fflags |= info2_flags_map[i].smb_fflag;
4611             }
4612         }
4613 }
4614
4615 static bool map_info2_flags_to_sbuf(const SMB_STRUCT_STAT *psbuf,
4616                                 const uint32_t smb_fflags,
4617                                 const uint32_t smb_fmask,
4618                                 int *stat_fflags)
4619 {
4620         uint32_t max_fmask = 0;
4621         int i;
4622
4623         *stat_fflags = psbuf->st_ex_flags;
4624
4625         /* For each flags requested in smb_fmask, check the state of the
4626          * corresponding flag in smb_fflags and set or clear the matching
4627          * stat flag.
4628          */
4629
4630         for (i = 0; i < ARRAY_SIZE(info2_flags_map); ++i) {
4631             max_fmask |= info2_flags_map[i].smb_fflag;
4632             if (smb_fmask & info2_flags_map[i].smb_fflag) {
4633                     if (smb_fflags & info2_flags_map[i].smb_fflag) {
4634                             *stat_fflags |= info2_flags_map[i].stat_fflag;
4635                     } else {
4636                             *stat_fflags &= ~info2_flags_map[i].stat_fflag;
4637                     }
4638             }
4639         }
4640
4641         /* If smb_fmask is asking to set any bits that are not supported by
4642          * our flag mappings, we should fail.
4643          */
4644         if ((smb_fmask & max_fmask) != smb_fmask) {
4645                 return False;
4646         }
4647
4648         return True;
4649 }
4650
4651
4652 /* Just like SMB_QUERY_FILE_UNIX_BASIC, but with the addition
4653  * of file flags and birth (create) time.
4654  */
4655 static char *store_file_unix_basic_info2(connection_struct *conn,
4656                                 char *pdata,
4657                                 files_struct *fsp,
4658                                 const SMB_STRUCT_STAT *psbuf)
4659 {
4660         uint32_t file_flags = 0;
4661         uint32_t flags_mask = 0;
4662
4663         pdata = store_file_unix_basic(conn, pdata, fsp, psbuf);
4664
4665         /* Create (birth) time 64 bit */
4666         put_long_date_timespec(TIMESTAMP_SET_NT_OR_BETTER,pdata, psbuf->st_ex_btime);
4667         pdata += 8;
4668
4669         map_info2_flags_from_sbuf(psbuf, &file_flags, &flags_mask);
4670         SIVAL(pdata, 0, file_flags); /* flags */
4671         SIVAL(pdata, 4, flags_mask); /* mask */
4672         pdata += 8;
4673
4674         return pdata;
4675 }
4676
4677 static NTSTATUS marshall_stream_info(unsigned int num_streams,
4678                                      const struct stream_struct *streams,
4679                                      char *data,
4680                                      unsigned int max_data_bytes,
4681                                      unsigned int *data_size)
4682 {
4683         unsigned int i;
4684         unsigned int ofs = 0;
4685
4686         if (max_data_bytes < 32) {
4687                 return NT_STATUS_INFO_LENGTH_MISMATCH;
4688         }
4689
4690         for (i = 0; i < num_streams; i++) {
4691                 unsigned int next_offset;
4692                 size_t namelen;
4693                 smb_ucs2_t *namebuf;
4694
4695                 if (!push_ucs2_talloc(talloc_tos(), &namebuf,
4696                                       streams[i].name, &namelen) ||
4697                     namelen <= 2)
4698                 {
4699                         return NT_STATUS_INVALID_PARAMETER;
4700                 }
4701
4702                 /*
4703                  * name_buf is now null-terminated, we need to marshall as not
4704                  * terminated
4705                  */
4706
4707                 namelen -= 2;
4708
4709                 /*
4710                  * We cannot overflow ...
4711                  */
4712                 if ((ofs + 24 + namelen) > max_data_bytes) {
4713                         DEBUG(10, ("refusing to overflow reply at stream %u\n",
4714                                 i));
4715                         TALLOC_FREE(namebuf);
4716                         return STATUS_BUFFER_OVERFLOW;
4717                 }
4718
4719                 SIVAL(data, ofs+4, namelen);
4720                 SOFF_T(data, ofs+8, streams[i].size);
4721                 SOFF_T(data, ofs+16, streams[i].alloc_size);
4722                 memcpy(data+ofs+24, namebuf, namelen);
4723                 TALLOC_FREE(namebuf);
4724
4725                 next_offset = ofs + 24 + namelen;
4726
4727                 if (i == num_streams-1) {
4728                         SIVAL(data, ofs, 0);
4729                 }
4730                 else {
4731                         unsigned int align = ndr_align_size(next_offset, 8);
4732
4733                         if ((next_offset + align) > max_data_bytes) {
4734                                 DEBUG(10, ("refusing to overflow align "
4735                                         "reply at stream %u\n",
4736                                         i));
4737                                 TALLOC_FREE(namebuf);
4738                                 return STATUS_BUFFER_OVERFLOW;
4739                         }
4740
4741                         memset(data+next_offset, 0, align);
4742                         next_offset += align;
4743
4744                         SIVAL(data, ofs, next_offset - ofs);
4745                         ofs = next_offset;
4746                 }
4747
4748                 ofs = next_offset;
4749         }
4750
4751         DEBUG(10, ("max_data: %u, data_size: %u\n", max_data_bytes, ofs));
4752
4753         *data_size = ofs;
4754
4755         return NT_STATUS_OK;
4756 }
4757
4758 /****************************************************************************
4759  Reply to a TRANSACT2_QFILEINFO on a PIPE !
4760 ****************************************************************************/
4761
4762 static void call_trans2qpipeinfo(connection_struct *conn,
4763                                  struct smb_request *req,
4764                                  unsigned int tran_call,
4765                                  char **pparams, int total_params,
4766                                  char **ppdata, int total_data,
4767                                  unsigned int max_data_bytes)
4768 {
4769         char *params = *pparams;
4770         char *pdata = *ppdata;
4771         unsigned int data_size = 0;
4772         unsigned int param_size = 2;
4773         uint16_t info_level;
4774         files_struct *fsp;
4775
4776         if (!params) {
4777                 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
4778                 return;
4779         }
4780
4781         if (total_params < 4) {
4782                 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
4783                 return;
4784         }
4785
4786         fsp = file_fsp(req, SVAL(params,0));
4787         if (!fsp_is_np(fsp)) {
4788                 reply_nterror(req, NT_STATUS_INVALID_HANDLE);
4789                 return;
4790         }
4791
4792         info_level = SVAL(params,2);
4793
4794         *pparams = (char *)SMB_REALLOC(*pparams,2);
4795         if (*pparams == NULL) {
4796                 reply_nterror(req, NT_STATUS_NO_MEMORY);
4797                 return;
4798         }
4799         params = *pparams;
4800         SSVAL(params,0,0);
4801         if (max_data_bytes + DIR_ENTRY_SAFETY_MARGIN < max_data_bytes) {
4802                 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
4803                 return;
4804         }
4805         data_size = max_data_bytes + DIR_ENTRY_SAFETY_MARGIN;
4806         *ppdata = (char *)SMB_REALLOC(*ppdata, data_size);
4807         if (*ppdata == NULL ) {
4808                 reply_nterror(req, NT_STATUS_NO_MEMORY);
4809                 return;
4810         }
4811         pdata = *ppdata;
4812
4813         switch (info_level) {
4814                 case SMB_FILE_STANDARD_INFORMATION:
4815                         memset(pdata,0,24);
4816                         SOFF_T(pdata,0,4096LL);
4817                         SIVAL(pdata,16,1);
4818                         SIVAL(pdata,20,1);
4819                         data_size = 24;
4820                         break;
4821
4822                 default:
4823                         reply_nterror(req, NT_STATUS_INVALID_LEVEL);
4824                         return;
4825         }
4826
4827         send_trans2_replies(conn, req, NT_STATUS_OK, params, param_size, *ppdata, data_size,
4828                             max_data_bytes);
4829
4830         return;
4831 }
4832
4833 NTSTATUS smbd_do_qfilepathinfo(connection_struct *conn,
4834                                TALLOC_CTX *mem_ctx,
4835                                uint16_t info_level,
4836                                files_struct *fsp,
4837                                struct smb_filename *smb_fname,
4838                                bool delete_pending,
4839                                struct timespec write_time_ts,
4840                                struct ea_list *ea_list,
4841                                int lock_data_count,
4842                                char *lock_data,
4843                                uint16_t flags2,
4844                                unsigned int max_data_bytes,
4845                                size_t *fixed_portion,
4846                                char **ppdata,
4847                                unsigned int *pdata_size)
4848 {
4849         char *pdata = *ppdata;
4850         char *dstart, *dend;
4851         unsigned int data_size;
4852         struct timespec create_time_ts, mtime_ts, atime_ts, ctime_ts;
4853         time_t create_time, mtime, atime, c_time;
4854         SMB_STRUCT_STAT *psbuf = &smb_fname->st;
4855         char *p;
4856         char *base_name;
4857         char *dos_fname;
4858         int mode;
4859         int nlink;
4860         NTSTATUS status;
4861         uint64_t file_size = 0;
4862         uint64_t pos = 0;
4863         uint64_t allocation_size = 0;
4864         uint64_t file_index = 0;
4865         uint32_t access_mask = 0;
4866         size_t len = 0;
4867
4868         if (INFO_LEVEL_IS_UNIX(info_level) && !lp_unix_extensions()) {
4869                 return NT_STATUS_INVALID_LEVEL;
4870         }
4871
4872         DEBUG(5,("smbd_do_qfilepathinfo: %s (%s) level=%d max_data=%u\n",
4873                  smb_fname_str_dbg(smb_fname),
4874                  fsp_fnum_dbg(fsp),
4875                  info_level, max_data_bytes));
4876
4877         mode = dos_mode(conn, smb_fname);
4878         nlink = psbuf->st_ex_nlink;
4879
4880         if (nlink && (mode&FILE_ATTRIBUTE_DIRECTORY)) {
4881                 nlink = 1;
4882         }
4883
4884         if ((nlink > 0) && delete_pending) {
4885                 nlink -= 1;
4886         }
4887
4888         if (max_data_bytes + DIR_ENTRY_SAFETY_MARGIN < max_data_bytes) {
4889                 return NT_STATUS_INVALID_PARAMETER;
4890         }
4891
4892         data_size = max_data_bytes + DIR_ENTRY_SAFETY_MARGIN;
4893         *ppdata = (char *)SMB_REALLOC(*ppdata, data_size);
4894         if (*ppdata == NULL) {
4895                 return NT_STATUS_NO_MEMORY;
4896         }
4897         pdata = *ppdata;
4898         dstart = pdata;
4899         dend = dstart + data_size - 1;
4900
4901         if (!null_timespec(write_time_ts) && !INFO_LEVEL_IS_UNIX(info_level)) {
4902                 update_stat_ex_mtime(psbuf, write_time_ts);
4903         }
4904
4905         create_time_ts = get_create_timespec(conn, fsp, smb_fname);
4906         mtime_ts = psbuf->st_ex_mtime;
4907         atime_ts = psbuf->st_ex_atime;
4908         ctime_ts = get_change_timespec(conn, fsp, smb_fname);
4909
4910         if (lp_dos_filetime_resolution(SNUM(conn))) {
4911                 dos_filetime_timespec(&create_time_ts);
4912                 dos_filetime_timespec(&mtime_ts);
4913                 dos_filetime_timespec(&atime_ts);
4914                 dos_filetime_timespec(&ctime_ts);
4915         }
4916
4917         create_time = convert_timespec_to_time_t(create_time_ts);
4918         mtime = convert_timespec_to_time_t(mtime_ts);
4919         atime = convert_timespec_to_time_t(atime_ts);
4920         c_time = convert_timespec_to_time_t(ctime_ts);
4921
4922         p = strrchr_m(smb_fname->base_name,'/');
4923         if (!p)
4924                 base_name = smb_fname->base_name;
4925         else
4926                 base_name = p+1;
4927
4928         /* NT expects the name to be in an exact form of the *full*
4929            filename. See the trans2 torture test */
4930         if (ISDOT(base_name)) {
4931                 dos_fname = talloc_strdup(mem_ctx, "\\");
4932                 if (!dos_fname) {
4933                         return NT_STATUS_NO_MEMORY;
4934                 }
4935         } else {
4936                 dos_fname = talloc_asprintf(mem_ctx,
4937                                 "\\%s",
4938                                 smb_fname->base_name);
4939                 if (!dos_fname) {
4940                         return NT_STATUS_NO_MEMORY;
4941                 }
4942                 if (is_ntfs_stream_smb_fname(smb_fname)) {
4943                         dos_fname = talloc_asprintf(dos_fname, "%s",
4944                                                     smb_fname->stream_name);
4945                         if (!dos_fname) {
4946                                 return NT_STATUS_NO_MEMORY;
4947                         }
4948                 }
4949
4950                 string_replace(dos_fname, '/', '\\');
4951         }
4952
4953         allocation_size = SMB_VFS_GET_ALLOC_SIZE(conn, fsp, psbuf);
4954
4955         if (!fsp) {
4956                 /* Do we have this path open ? */
4957                 files_struct *fsp1;
4958                 struct file_id fileid = vfs_file_id_from_sbuf(conn, psbuf);
4959                 fsp1 = file_find_di_first(conn->sconn, fileid);
4960                 if (fsp1 && fsp1->initial_allocation_size) {
4961                         allocation_size = SMB_VFS_GET_ALLOC_SIZE(conn, fsp1, psbuf);
4962                 }
4963         }
4964
4965         if (!(mode & FILE_ATTRIBUTE_DIRECTORY)) {
4966                 file_size = get_file_size_stat(psbuf);
4967         }
4968
4969         if (fsp) {
4970                 pos = fsp->fh->position_information;
4971         }
4972
4973         if (fsp) {
4974                 access_mask = fsp->access_mask;
4975         } else {
4976                 /* GENERIC_EXECUTE mapping from Windows */
4977                 access_mask = 0x12019F;
4978         }
4979
4980         /* This should be an index number - looks like
4981            dev/ino to me :-)
4982
4983            I think this causes us to fail the IFSKIT
4984            BasicFileInformationTest. -tpot */
4985         file_index = get_FileIndex(conn, psbuf);
4986
4987         *fixed_portion = 0;
4988
4989         switch (info_level) {
4990                 case SMB_INFO_STANDARD:
4991                         DEBUG(10,("smbd_do_qfilepathinfo: SMB_INFO_STANDARD\n"));
4992                         data_size = 22;
4993                         srv_put_dos_date2(pdata,l1_fdateCreation,create_time);
4994                         srv_put_dos_date2(pdata,l1_fdateLastAccess,atime);
4995                         srv_put_dos_date2(pdata,l1_fdateLastWrite,mtime); /* write time */
4996                         SIVAL(pdata,l1_cbFile,(uint32_t)file_size);
4997                         SIVAL(pdata,l1_cbFileAlloc,(uint32_t)allocation_size);
4998                         SSVAL(pdata,l1_attrFile,mode);
4999                         break;
5000
5001                 case SMB_INFO_QUERY_EA_SIZE:
5002                 {
5003                         unsigned int ea_size =
5004                             estimate_ea_size(conn, fsp,
5005                                              smb_fname);
5006                         DEBUG(10,("smbd_do_qfilepathinfo: SMB_INFO_QUERY_EA_SIZE\n"));
5007                         data_size = 26;
5008                         srv_put_dos_date2(pdata,0,create_time);
5009                         srv_put_dos_date2(pdata,4,atime);
5010                         srv_put_dos_date2(pdata,8,mtime); /* write time */
5011                         SIVAL(pdata,12,(uint32_t)file_size);
5012                         SIVAL(pdata,16,(uint32_t)allocation_size);
5013                         SSVAL(pdata,20,mode);
5014                         SIVAL(pdata,22,ea_size);
5015                         break;
5016                 }
5017
5018                 case SMB_INFO_IS_NAME_VALID:
5019                         DEBUG(10,("smbd_do_qfilepathinfo: SMB_INFO_IS_NAME_VALID\n"));
5020                         if (fsp) {
5021                                 /* os/2 needs this ? really ?*/
5022                                 return NT_STATUS_DOS(ERRDOS, ERRbadfunc);
5023                         }
5024                         /* This is only reached for qpathinfo */
5025                         data_size = 0;
5026                         break;
5027
5028                 case SMB_INFO_QUERY_EAS_FROM_LIST:
5029                 {
5030                         size_t total_ea_len = 0;
5031                         struct ea_list *ea_file_list = NULL;
5032                         DEBUG(10,("smbd_do_qfilepathinfo: SMB_INFO_QUERY_EAS_FROM_LIST\n"));
5033
5034                         status =
5035                             get_ea_list_from_file(mem_ctx, conn, fsp,
5036                                                   smb_fname,
5037                                                   &total_ea_len, &ea_file_list);
5038                         if (!NT_STATUS_IS_OK(status)) {
5039                                 return status;
5040                         }
5041
5042                         ea_list = ea_list_union(ea_list, ea_file_list, &total_ea_len);
5043
5044                         if (!ea_list || (total_ea_len > data_size)) {
5045                                 data_size = 4;
5046                                 SIVAL(pdata,0,4);   /* EA List Length must be set to 4 if no EA's. */
5047                                 break;
5048                         }
5049
5050                         data_size = fill_ea_buffer(mem_ctx, pdata, data_size, conn, ea_list);
5051                         break;
5052                 }
5053
5054                 case SMB_INFO_QUERY_ALL_EAS:
5055                 {
5056                         /* We have data_size bytes to put EA's into. */
5057                         size_t total_ea_len = 0;
5058                         DEBUG(10,("smbd_do_qfilepathinfo: SMB_INFO_QUERY_ALL_EAS\n"));
5059
5060                         status = get_ea_list_from_file(mem_ctx, conn, fsp,
5061                                                         smb_fname,
5062                                                         &total_ea_len, &ea_list);
5063                         if (!NT_STATUS_IS_OK(status)) {
5064                                 return status;
5065                         }
5066
5067                         if (!ea_list || (total_ea_len > data_size)) {
5068                                 data_size = 4;
5069                                 SIVAL(pdata,0,4);   /* EA List Length must be set to 4 if no EA's. */
5070                                 break;
5071                         }
5072
5073                         data_size = fill_ea_buffer(mem_ctx, pdata, data_size, conn, ea_list);
5074                         break;
5075                 }
5076
5077                 case 0xFF0F:/*SMB2_INFO_QUERY_ALL_EAS*/
5078                 {
5079                         /* This is FileFullEaInformation - 0xF which maps to
5080                          * 1015 (decimal) in smbd_do_setfilepathinfo. */
5081
5082                         /* We have data_size bytes to put EA's into. */
5083                         size_t total_ea_len = 0;
5084                         struct ea_list *ea_file_list = NULL;
5085
5086                         DEBUG(10,("smbd_do_qfilepathinfo: SMB2_INFO_QUERY_ALL_EAS\n"));
5087
5088                         /*TODO: add filtering and index handling */
5089
5090                         status  =
5091                                 get_ea_list_from_file(mem_ctx, conn, fsp,
5092                                                   smb_fname,
5093                                                   &total_ea_len, &ea_file_list);
5094                         if (!NT_STATUS_IS_OK(status)) {
5095                                 return status;
5096                         }
5097                         if (!ea_file_list) {
5098                                 return NT_STATUS_NO_EAS_ON_FILE;
5099                         }
5100
5101                         status = fill_ea_chained_buffer(mem_ctx,
5102                                                         pdata,
5103                                                         data_size,
5104                                                         &data_size,
5105                                                         conn, ea_file_list);
5106                         if (!NT_STATUS_IS_OK(status)) {
5107                                 return status;
5108                         }
5109                         break;
5110                 }
5111
5112                 case SMB_FILE_BASIC_INFORMATION:
5113                 case SMB_QUERY_FILE_BASIC_INFO:
5114
5115                         if (info_level == SMB_QUERY_FILE_BASIC_INFO) {
5116                                 DEBUG(10,("smbd_do_qfilepathinfo: SMB_QUERY_FILE_BASIC_INFO\n"));
5117                                 data_size = 36; /* w95 returns 40 bytes not 36 - why ?. */
5118                         } else {
5119                                 DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_BASIC_INFORMATION\n"));
5120                                 data_size = 40;
5121                                 SIVAL(pdata,36,0);
5122                         }
5123                         put_long_date_timespec(conn->ts_res,pdata,create_time_ts);
5124                         put_long_date_timespec(conn->ts_res,pdata+8,atime_ts);
5125                         put_long_date_timespec(conn->ts_res,pdata+16,mtime_ts); /* write time */
5126                         put_long_date_timespec(conn->ts_res,pdata+24,ctime_ts); /* change time */
5127                         SIVAL(pdata,32,mode);
5128
5129                         DEBUG(5,("SMB_QFBI - "));
5130                         DEBUG(5,("create: %s ", ctime(&create_time)));
5131                         DEBUG(5,("access: %s ", ctime(&atime)));
5132                         DEBUG(5,("write: %s ", ctime(&mtime)));
5133                         DEBUG(5,("change: %s ", ctime(&c_time)));
5134                         DEBUG(5,("mode: %x\n", mode));
5135                         *fixed_portion = data_size;
5136                         break;
5137
5138                 case SMB_FILE_STANDARD_INFORMATION:
5139                 case SMB_QUERY_FILE_STANDARD_INFO:
5140
5141                         DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_STANDARD_INFORMATION\n"));
5142                         data_size = 24;
5143                         SOFF_T(pdata,0,allocation_size);
5144                         SOFF_T(pdata,8,file_size);
5145                         SIVAL(pdata,16,nlink);
5146                         SCVAL(pdata,20,delete_pending?1:0);
5147                         SCVAL(pdata,21,(mode&FILE_ATTRIBUTE_DIRECTORY)?1:0);
5148                         SSVAL(pdata,22,0); /* Padding. */
5149                         *fixed_portion = 24;
5150                         break;
5151
5152                 case SMB_FILE_EA_INFORMATION:
5153                 case SMB_QUERY_FILE_EA_INFO:
5154                 {
5155                         unsigned int ea_size =
5156                             estimate_ea_size(conn, fsp, smb_fname);
5157                         DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_EA_INFORMATION\n"));
5158                         data_size = 4;
5159                         *fixed_portion = 4;
5160                         SIVAL(pdata,0,ea_size);
5161                         break;
5162                 }
5163
5164                 /* Get the 8.3 name - used if NT SMB was negotiated. */
5165                 case SMB_QUERY_FILE_ALT_NAME_INFO:
5166                 case SMB_FILE_ALTERNATE_NAME_INFORMATION:
5167                 {
5168                         char mangled_name[13];
5169                         DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_ALTERNATE_NAME_INFORMATION\n"));
5170                         if (!name_to_8_3(base_name,mangled_name,
5171                                                 True,conn->params)) {
5172                                 return NT_STATUS_NO_MEMORY;
5173                         }
5174                         status = srvstr_push(dstart, flags2,
5175                                           pdata+4, mangled_name,
5176                                           PTR_DIFF(dend, pdata+4),
5177                                           STR_UNICODE, &len);
5178                         if (!NT_STATUS_IS_OK(status)) {
5179                                 return status;
5180                         }
5181                         data_size = 4 + len;
5182                         SIVAL(pdata,0,len);
5183                         *fixed_portion = 8;
5184                         break;
5185                 }
5186
5187                 case SMB_QUERY_FILE_NAME_INFO:
5188                 {
5189                         /*
5190                           this must be *exactly* right for ACLs on mapped drives to work
5191                          */
5192                         status = srvstr_push(dstart, flags2,
5193                                           pdata+4, dos_fname,
5194                                           PTR_DIFF(dend, pdata+4),
5195                                           STR_UNICODE, &len);
5196                         if (!NT_STATUS_IS_OK(status)) {
5197                                 return status;
5198                         }
5199                         DEBUG(10,("smbd_do_qfilepathinfo: SMB_QUERY_FILE_NAME_INFO\n"));
5200                         data_size = 4 + len;
5201                         SIVAL(pdata,0,len);
5202                         break;
5203                 }
5204
5205                 case SMB_FILE_ALLOCATION_INFORMATION:
5206                 case SMB_QUERY_FILE_ALLOCATION_INFO:
5207                         DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_ALLOCATION_INFORMATION\n"));
5208                         data_size = 8;
5209                         SOFF_T(pdata,0,allocation_size);
5210                         break;
5211
5212                 case SMB_FILE_END_OF_FILE_INFORMATION:
5213                 case SMB_QUERY_FILE_END_OF_FILEINFO:
5214                         DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_END_OF_FILE_INFORMATION\n"));
5215                         data_size = 8;
5216                         SOFF_T(pdata,0,file_size);
5217                         break;
5218
5219                 case SMB_QUERY_FILE_ALL_INFO:
5220                 case SMB_FILE_ALL_INFORMATION:
5221                 {
5222                         unsigned int ea_size =
5223                             estimate_ea_size(conn, fsp, smb_fname);
5224                         DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_ALL_INFORMATION\n"));
5225                         put_long_date_timespec(conn->ts_res,pdata,create_time_ts);
5226                         put_long_date_timespec(conn->ts_res,pdata+8,atime_ts);
5227                         put_long_date_timespec(conn->ts_res,pdata+16,mtime_ts); /* write time */
5228                         put_long_date_timespec(conn->ts_res,pdata+24,ctime_ts); /* change time */
5229                         SIVAL(pdata,32,mode);
5230                         SIVAL(pdata,36,0); /* padding. */
5231                         pdata += 40;
5232                         SOFF_T(pdata,0,allocation_size);
5233                         SOFF_T(pdata,8,file_size);
5234                         SIVAL(pdata,16,nlink);
5235                         SCVAL(pdata,20,delete_pending);
5236                         SCVAL(pdata,21,(mode&FILE_ATTRIBUTE_DIRECTORY)?1:0);
5237                         SSVAL(pdata,22,0);
5238                         pdata += 24;
5239                         SIVAL(pdata,0,ea_size);
5240                         pdata += 4; /* EA info */
5241                         status = srvstr_push(dstart, flags2,
5242                                           pdata+4, dos_fname,
5243                                           PTR_DIFF(dend, pdata+4),
5244                                           STR_UNICODE, &len);
5245                         if (!NT_STATUS_IS_OK(status)) {
5246                                 return status;
5247                         }
5248                         SIVAL(pdata,0,len);
5249                         pdata += 4 + len;
5250                         data_size = PTR_DIFF(pdata,(*ppdata));
5251                         *fixed_portion = 10;
5252                         break;
5253                 }
5254
5255                 case 0xFF12:/*SMB2_FILE_ALL_INFORMATION*/
5256                 {
5257                         unsigned int ea_size =
5258                             estimate_ea_size(conn, fsp, smb_fname);
5259                         DEBUG(10,("smbd_do_qfilepathinfo: SMB2_FILE_ALL_INFORMATION\n"));
5260                         put_long_date_timespec(conn->ts_res,pdata+0x00,create_time_ts);
5261                         put_long_date_timespec(conn->ts_res,pdata+0x08,atime_ts);
5262                         put_long_date_timespec(conn->ts_res,pdata+0x10,mtime_ts); /* write time */
5263                         put_long_date_timespec(conn->ts_res,pdata+0x18,ctime_ts); /* change time */
5264                         SIVAL(pdata,    0x20, mode);
5265                         SIVAL(pdata,    0x24, 0); /* padding. */
5266                         SBVAL(pdata,    0x28, allocation_size);
5267                         SBVAL(pdata,    0x30, file_size);
5268                         SIVAL(pdata,    0x38, nlink);
5269                         SCVAL(pdata,    0x3C, delete_pending);
5270                         SCVAL(pdata,    0x3D, (mode&FILE_ATTRIBUTE_DIRECTORY)?1:0);
5271                         SSVAL(pdata,    0x3E, 0); /* padding */
5272                         SBVAL(pdata,    0x40, file_index);
5273                         SIVAL(pdata,    0x48, ea_size);
5274                         SIVAL(pdata,    0x4C, access_mask);
5275                         SBVAL(pdata,    0x50, pos);
5276                         SIVAL(pdata,    0x58, mode); /*TODO: mode != mode fix this!!! */
5277                         SIVAL(pdata,    0x5C, 0); /* No alignment needed. */
5278
5279                         pdata += 0x60;
5280
5281                         status = srvstr_push(dstart, flags2,
5282                                           pdata+4, dos_fname,
5283                                           PTR_DIFF(dend, pdata+4),
5284                                           STR_UNICODE, &len);
5285                         if (!NT_STATUS_IS_OK(status)) {
5286                                 return status;
5287                         }
5288                         SIVAL(pdata,0,len);
5289                         pdata += 4 + len;
5290                         data_size = PTR_DIFF(pdata,(*ppdata));
5291                         *fixed_portion = 104;
5292                         break;
5293                 }
5294                 case SMB_FILE_INTERNAL_INFORMATION:
5295
5296                         DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_INTERNAL_INFORMATION\n"));
5297                         SBVAL(pdata, 0, file_index);
5298                         data_size = 8;
5299                         *fixed_portion = 8;
5300                         break;
5301
5302                 case SMB_FILE_ACCESS_INFORMATION:
5303                         DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_ACCESS_INFORMATION\n"));
5304                         SIVAL(pdata, 0, access_mask);
5305                         data_size = 4;
5306                         *fixed_portion = 4;
5307                         break;
5308
5309                 case SMB_FILE_NAME_INFORMATION:
5310                         /* Pathname with leading '\'. */
5311                         {
5312                                 size_t byte_len;
5313                                 byte_len = dos_PutUniCode(pdata+4,dos_fname,(size_t)max_data_bytes,False);
5314                                 DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_NAME_INFORMATION\n"));
5315                                 SIVAL(pdata,0,byte_len);
5316                                 data_size = 4 + byte_len;
5317                                 break;
5318                         }
5319
5320                 case SMB_FILE_DISPOSITION_INFORMATION:
5321                         DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_DISPOSITION_INFORMATION\n"));
5322                         data_size = 1;
5323                         SCVAL(pdata,0,delete_pending);
5324                         *fixed_portion = 1;
5325                         break;
5326
5327                 case SMB_FILE_POSITION_INFORMATION:
5328                         DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_POSITION_INFORMATION\n"));
5329                         data_size = 8;
5330                         SOFF_T(pdata,0,pos);
5331                         *fixed_portion = 8;
5332                         break;
5333
5334                 case SMB_FILE_MODE_INFORMATION:
5335                         DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_MODE_INFORMATION\n"));
5336                         SIVAL(pdata,0,mode);
5337                         data_size = 4;
5338                         *fixed_portion = 4;
5339                         break;
5340
5341                 case SMB_FILE_ALIGNMENT_INFORMATION:
5342                         DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_ALIGNMENT_INFORMATION\n"));
5343                         SIVAL(pdata,0,0); /* No alignment needed. */
5344                         data_size = 4;
5345                         *fixed_portion = 4;
5346                         break;
5347
5348                 /*
5349                  * NT4 server just returns "invalid query" to this - if we try
5350                  * to answer it then NTws gets a BSOD! (tridge).  W2K seems to
5351                  * want this. JRA.
5352                  */
5353                 /* The first statement above is false - verified using Thursby
5354                  * client against NT4 -- gcolley.
5355                  */
5356                 case SMB_QUERY_FILE_STREAM_INFO:
5357                 case SMB_FILE_STREAM_INFORMATION: {
5358                         unsigned int num_streams = 0;
5359                         struct stream_struct *streams = NULL;
5360
5361                         DEBUG(10,("smbd_do_qfilepathinfo: "
5362                                   "SMB_FILE_STREAM_INFORMATION\n"));
5363
5364                         if (is_ntfs_stream_smb_fname(smb_fname)) {
5365                                 return NT_STATUS_INVALID_PARAMETER;
5366                         }
5367
5368                         status = vfs_streaminfo(conn,
5369                                                 fsp,
5370                                                 smb_fname,
5371                                                 talloc_tos(),
5372                                                 &num_streams,
5373                                                 &streams);
5374
5375                         if (!NT_STATUS_IS_OK(status)) {
5376                                 DEBUG(10, ("could not get stream info: %s\n",
5377                                            nt_errstr(status)));
5378                                 return status;
5379                         }
5380
5381                         status = marshall_stream_info(num_streams, streams,
5382                                                       pdata, max_data_bytes,
5383                                                       &data_size);
5384
5385                         if (!NT_STATUS_IS_OK(status)) {
5386                                 DEBUG(10, ("marshall_stream_info failed: %s\n",
5387                                            nt_errstr(status)));
5388                                 TALLOC_FREE(streams);
5389                                 return status;
5390                         }
5391
5392                         TALLOC_FREE(streams);
5393
5394                         *fixed_portion = 32;
5395
5396                         break;
5397                 }
5398                 case SMB_QUERY_COMPRESSION_INFO:
5399                 case SMB_FILE_COMPRESSION_INFORMATION:
5400                         DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_COMPRESSION_INFORMATION\n"));
5401                         SOFF_T(pdata,0,file_size);
5402                         SIVAL(pdata,8,0); /* ??? */
5403                         SIVAL(pdata,12,0); /* ??? */
5404                         data_size = 16;
5405                         *fixed_portion = 16;
5406                         break;
5407
5408                 case SMB_FILE_NETWORK_OPEN_INFORMATION:
5409                         DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_NETWORK_OPEN_INFORMATION\n"));
5410                         put_long_date_timespec(conn->ts_res,pdata,create_time_ts);
5411                         put_long_date_timespec(conn->ts_res,pdata+8,atime_ts);
5412                         put_long_date_timespec(conn->ts_res,pdata+16,mtime_ts); /* write time */
5413                         put_long_date_timespec(conn->ts_res,pdata+24,ctime_ts); /* change time */
5414                         SOFF_T(pdata,32,allocation_size);
5415                         SOFF_T(pdata,40,file_size);
5416                         SIVAL(pdata,48,mode);
5417                         SIVAL(pdata,52,0); /* ??? */
5418                         data_size = 56;
5419                         *fixed_portion = 56;
5420                         break;
5421
5422                 case SMB_FILE_ATTRIBUTE_TAG_INFORMATION:
5423                         DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_ATTRIBUTE_TAG_INFORMATION\n"));
5424                         SIVAL(pdata,0,mode);
5425                         SIVAL(pdata,4,0);
5426                         data_size = 8;
5427                         *fixed_portion = 8;
5428                         break;
5429
5430                 /*
5431                  * CIFS UNIX Extensions.
5432                  */
5433
5434                 case SMB_QUERY_FILE_UNIX_BASIC:
5435
5436                         pdata = store_file_unix_basic(conn, pdata, fsp, psbuf);
5437                         data_size = PTR_DIFF(pdata,(*ppdata));
5438
5439                         DEBUG(4,("smbd_do_qfilepathinfo: "
5440                                  "SMB_QUERY_FILE_UNIX_BASIC\n"));
5441                         dump_data(4, (uint8_t *)(*ppdata), data_size);
5442
5443                         break;
5444
5445                 case SMB_QUERY_FILE_UNIX_INFO2:
5446
5447                         pdata = store_file_unix_basic_info2(conn, pdata, fsp, psbuf);
5448                         data_size = PTR_DIFF(pdata,(*ppdata));
5449
5450                         {
5451                                 int i;
5452                                 DEBUG(4,("smbd_do_qfilepathinfo: SMB_QUERY_FILE_UNIX_INFO2 "));
5453
5454                                 for (i=0; i<100; i++)
5455                                         DEBUG(4,("%d=%x, ",i, (*ppdata)[i]));
5456                                 DEBUG(4,("\n"));
5457                         }
5458
5459                         break;
5460
5461                 case SMB_QUERY_FILE_UNIX_LINK:
5462                         {
5463                                 int link_len = 0;
5464                                 char *buffer = talloc_array(mem_ctx, char, PATH_MAX+1);
5465
5466                                 if (!buffer) {
5467                                         return NT_STATUS_NO_MEMORY;
5468                                 }
5469
5470                                 DEBUG(10,("smbd_do_qfilepathinfo: SMB_QUERY_FILE_UNIX_LINK\n"));
5471 #ifdef S_ISLNK
5472                                 if(!S_ISLNK(psbuf->st_ex_mode)) {
5473                                         return NT_STATUS_DOS(ERRSRV, ERRbadlink);
5474                                 }
5475 #else
5476                                 return NT_STATUS_DOS(ERRDOS, ERRbadlink);
5477 #endif
5478                                 link_len = SMB_VFS_READLINK(conn,
5479                                                        smb_fname,
5480                                                        buffer, PATH_MAX);
5481                                 if (link_len == -1) {
5482                                         return map_nt_error_from_unix(errno);
5483                                 }
5484                                 buffer[link_len] = 0;
5485                                 status = srvstr_push(dstart, flags2,
5486                                                   pdata, buffer,
5487                                                   PTR_DIFF(dend, pdata),
5488                                                   STR_TERMINATE, &len);
5489                                 if (!NT_STATUS_IS_OK(status)) {
5490                                         return status;
5491                                 }
5492                                 pdata += len;
5493                                 data_size = PTR_DIFF(pdata,(*ppdata));
5494
5495                                 break;
5496                         }
5497
5498 #if defined(HAVE_POSIX_ACLS)
5499                 case SMB_QUERY_POSIX_ACL:
5500                         {
5501                                 SMB_ACL_T file_acl = NULL;
5502                                 SMB_ACL_T def_acl = NULL;
5503                                 uint16_t num_file_acls = 0;
5504                                 uint16_t num_def_acls = 0;
5505
5506                                 status = refuse_symlink(conn,
5507                                                 fsp,
5508                                                 smb_fname);
5509                                 if (!NT_STATUS_IS_OK(status)) {
5510                                         return status;
5511                                 }
5512
5513                                 if (fsp && fsp->fh->fd != -1) {
5514                                         file_acl = SMB_VFS_SYS_ACL_GET_FD(fsp,
5515                                                 talloc_tos());
5516                                 } else {
5517                                         file_acl =
5518                                             SMB_VFS_SYS_ACL_GET_FILE(conn,
5519                                                 smb_fname,
5520                                                 SMB_ACL_TYPE_ACCESS,
5521                                                 talloc_tos());
5522                                 }
5523
5524                                 if (file_acl == NULL && no_acl_syscall_error(errno)) {
5525                                         DEBUG(5,("smbd_do_qfilepathinfo: ACLs "
5526                                                  "not implemented on "
5527                                                  "filesystem containing %s\n",
5528                                                  smb_fname->base_name));
5529                                         return NT_STATUS_NOT_IMPLEMENTED;
5530                                 }
5531
5532                                 if (S_ISDIR(psbuf->st_ex_mode)) {
5533                                         if (fsp && fsp->is_directory) {
5534                                                 def_acl =
5535                                                     SMB_VFS_SYS_ACL_GET_FILE(
5536                                                             conn,
5537                                                             fsp->fsp_name,
5538                                                             SMB_ACL_TYPE_DEFAULT,
5539                                                             talloc_tos());
5540                                         } else {
5541                                                 def_acl =
5542                                                     SMB_VFS_SYS_ACL_GET_FILE(
5543                                                             conn,
5544                                                             smb_fname,
5545                                                             SMB_ACL_TYPE_DEFAULT,
5546                                                             talloc_tos());
5547                                         }
5548                                         def_acl = free_empty_sys_acl(conn, def_acl);
5549                                 }
5550
5551                                 num_file_acls = count_acl_entries(conn, file_acl);
5552                                 num_def_acls = count_acl_entries(conn, def_acl);
5553
5554                                 if ( data_size < (num_file_acls + num_def_acls)*SMB_POSIX_ACL_ENTRY_SIZE + SMB_POSIX_ACL_HEADER_SIZE) {
5555                                         DEBUG(5,("smbd_do_qfilepathinfo: data_size too small (%u) need %u\n",
5556                                                 data_size,
5557                                                 (unsigned int)((num_file_acls + num_def_acls)*SMB_POSIX_ACL_ENTRY_SIZE +
5558                                                         SMB_POSIX_ACL_HEADER_SIZE) ));
5559                                         if (file_acl) {
5560                                                 TALLOC_FREE(file_acl);
5561                                         }
5562                                         if (def_acl) {
5563                                                 TALLOC_FREE(def_acl);
5564                                         }
5565                                         return NT_STATUS_BUFFER_TOO_SMALL;
5566                                 }
5567
5568                                 SSVAL(pdata,0,SMB_POSIX_ACL_VERSION);
5569                                 SSVAL(pdata,2,num_file_acls);
5570                                 SSVAL(pdata,4,num_def_acls);
5571                                 if (!marshall_posix_acl(conn, pdata + SMB_POSIX_ACL_HEADER_SIZE, psbuf, file_acl)) {
5572                                         if (file_acl) {
5573                                                 TALLOC_FREE(file_acl);
5574                                         }
5575                                         if (def_acl) {
5576                                                 TALLOC_FREE(def_acl);
5577                                         }
5578                                         return NT_STATUS_INTERNAL_ERROR;
5579                                 }
5580                                 if (!marshall_posix_acl(conn, pdata + SMB_POSIX_ACL_HEADER_SIZE + (num_file_acls*SMB_POSIX_ACL_ENTRY_SIZE), psbuf, def_acl)) {
5581                                         if (file_acl) {
5582                                                 TALLOC_FREE(file_acl);
5583                                         }
5584                                         if (def_acl) {
5585                                                 TALLOC_FREE(def_acl);
5586                                         }
5587                                         return NT_STATUS_INTERNAL_ERROR;
5588                                 }
5589
5590                                 if (file_acl) {
5591                                         TALLOC_FREE(file_acl);
5592                                 }
5593                                 if (def_acl) {
5594                                         TALLOC_FREE(def_acl);
5595                                 }
5596                                 data_size = (num_file_acls + num_def_acls)*SMB_POSIX_ACL_ENTRY_SIZE + SMB_POSIX_ACL_HEADER_SIZE;
5597                                 break;
5598                         }
5599 #endif
5600
5601
5602                 case SMB_QUERY_POSIX_LOCK:
5603                 {
5604                         uint64_t count;
5605                         uint64_t offset;
5606                         uint64_t smblctx;
5607                         enum brl_type lock_type;
5608
5609                         /* We need an open file with a real fd for this. */
5610                         if (!fsp || fsp->fh->fd == -1) {
5611                                 return NT_STATUS_INVALID_LEVEL;
5612                         }
5613
5614                         if (lock_data_count != POSIX_LOCK_DATA_SIZE) {
5615                                 return NT_STATUS_INVALID_PARAMETER;
5616                         }
5617
5618                         switch (SVAL(pdata, POSIX_LOCK_TYPE_OFFSET)) {
5619                                 case POSIX_LOCK_TYPE_READ:
5620                                         lock_type = READ_LOCK;
5621                                         break;
5622                                 case POSIX_LOCK_TYPE_WRITE:
5623                                         lock_type = WRITE_LOCK;
5624                                         break;
5625                                 case POSIX_LOCK_TYPE_UNLOCK:
5626                                 default:
5627                                         /* There's no point in asking for an unlock... */
5628                                         return NT_STATUS_INVALID_PARAMETER;
5629                         }
5630
5631                         smblctx = (uint64_t)IVAL(pdata, POSIX_LOCK_PID_OFFSET);
5632                         offset = BVAL(pdata,POSIX_LOCK_START_OFFSET);
5633                         count = BVAL(pdata,POSIX_LOCK_LEN_OFFSET);
5634
5635                         status = query_lock(fsp,
5636                                         &smblctx,
5637                                         &count,
5638                                         &offset,
5639                                         &lock_type,
5640                                         POSIX_LOCK);
5641
5642                         if (ERROR_WAS_LOCK_DENIED(status)) {
5643                                 /* Here we need to report who has it locked... */
5644                                 data_size = POSIX_LOCK_DATA_SIZE;
5645
5646                                 SSVAL(pdata, POSIX_LOCK_TYPE_OFFSET, lock_type);
5647                                 SSVAL(pdata, POSIX_LOCK_FLAGS_OFFSET, 0);
5648                                 SIVAL(pdata, POSIX_LOCK_PID_OFFSET, (uint32_t)smblctx);
5649                                 SBVAL(pdata, POSIX_LOCK_START_OFFSET, offset);
5650                                 SBVAL(pdata, POSIX_LOCK_LEN_OFFSET, count);
5651
5652                         } else if (NT_STATUS_IS_OK(status)) {
5653                                 /* For success we just return a copy of what we sent
5654                                    with the lock type set to POSIX_LOCK_TYPE_UNLOCK. */
5655                                 data_size = POSIX_LOCK_DATA_SIZE;
5656                                 memcpy(pdata, lock_data, POSIX_LOCK_DATA_SIZE);
5657                                 SSVAL(pdata, POSIX_LOCK_TYPE_OFFSET, POSIX_LOCK_TYPE_UNLOCK);
5658                         } else {
5659                                 return status;
5660                         }
5661                         break;
5662                 }
5663
5664                 default:
5665                         return NT_STATUS_INVALID_LEVEL;
5666         }
5667
5668         *pdata_size = data_size;
5669         return NT_STATUS_OK;
5670 }
5671
5672 /****************************************************************************
5673  Reply to a TRANS2_QFILEPATHINFO or TRANSACT2_QFILEINFO (query file info by
5674  file name or file id).
5675 ****************************************************************************/
5676
5677 static void call_trans2qfilepathinfo(connection_struct *conn,
5678                                      struct smb_request *req,
5679                                      unsigned int tran_call,
5680                                      char **pparams, int total_params,
5681                                      char **ppdata, int total_data,
5682                                      unsigned int max_data_bytes)
5683 {
5684         char *params = *pparams;
5685         char *pdata = *ppdata;
5686         uint16_t info_level;
5687         unsigned int data_size = 0;
5688         unsigned int param_size = 2;
5689         struct smb_filename *smb_fname = NULL;
5690         bool delete_pending = False;
5691         struct timespec write_time_ts;
5692         files_struct *fsp = NULL;
5693         struct file_id fileid;
5694         struct ea_list *ea_list = NULL;
5695         int lock_data_count = 0;
5696         char *lock_data = NULL;
5697         size_t fixed_portion;
5698         NTSTATUS status = NT_STATUS_OK;
5699
5700         if (!params) {
5701                 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
5702                 return;
5703         }
5704
5705         ZERO_STRUCT(write_time_ts);
5706
5707         if (tran_call == TRANSACT2_QFILEINFO) {
5708                 if (total_params < 4) {
5709                         reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
5710                         return;
5711                 }
5712
5713                 if (IS_IPC(conn)) {
5714                         call_trans2qpipeinfo(conn, req, tran_call,
5715                                              pparams, total_params,
5716                                              ppdata, total_data,
5717                                              max_data_bytes);
5718                         return;
5719                 }
5720
5721                 fsp = file_fsp(req, SVAL(params,0));
5722                 info_level = SVAL(params,2);
5723
5724                 DEBUG(3,("call_trans2qfilepathinfo: TRANSACT2_QFILEINFO: level = %d\n", info_level));
5725
5726                 if (INFO_LEVEL_IS_UNIX(info_level) && !lp_unix_extensions()) {
5727                         reply_nterror(req, NT_STATUS_INVALID_LEVEL);
5728                         return;
5729                 }
5730
5731                 /* Initial check for valid fsp ptr. */
5732                 if (!check_fsp_open(conn, req, fsp)) {
5733                         return;
5734                 }
5735
5736                 smb_fname = cp_smb_filename(talloc_tos(), fsp->fsp_name);
5737                 if (smb_fname == NULL) {
5738                         reply_nterror(req, NT_STATUS_NO_MEMORY);
5739                         return;
5740                 }
5741
5742                 if(fsp->fake_file_handle) {
5743                         /*
5744                          * This is actually for the QUOTA_FAKE_FILE --metze
5745                          */
5746
5747                         /* We know this name is ok, it's already passed the checks. */
5748
5749                 } else if(fsp->fh->fd == -1) {
5750                         /*
5751                          * This is actually a QFILEINFO on a directory
5752                          * handle (returned from an NT SMB). NT5.0 seems
5753                          * to do this call. JRA.
5754                          */
5755
5756                         if (INFO_LEVEL_IS_UNIX(info_level)) {
5757                                 /* Always do lstat for UNIX calls. */
5758                                 if (SMB_VFS_LSTAT(conn, smb_fname)) {
5759                                         DEBUG(3,("call_trans2qfilepathinfo: "
5760                                                  "SMB_VFS_LSTAT of %s failed "
5761                                                  "(%s)\n",
5762                                                  smb_fname_str_dbg(smb_fname),
5763                                                  strerror(errno)));
5764                                         reply_nterror(req,
5765                                                 map_nt_error_from_unix(errno));
5766                                         return;
5767                                 }
5768                         } else if (SMB_VFS_STAT(conn, smb_fname)) {
5769                                 DEBUG(3,("call_trans2qfilepathinfo: "
5770                                          "SMB_VFS_STAT of %s failed (%s)\n",
5771                                          smb_fname_str_dbg(smb_fname),
5772                                          strerror(errno)));
5773                                 reply_nterror(req,
5774                                         map_nt_error_from_unix(errno));
5775                                 return;
5776                         }
5777
5778                         fileid = vfs_file_id_from_sbuf(conn, &smb_fname->st);
5779                         get_file_infos(fileid, fsp->name_hash, &delete_pending, &write_time_ts);
5780                 } else {
5781                         /*
5782                          * Original code - this is an open file.
5783                          */
5784                         if (SMB_VFS_FSTAT(fsp, &smb_fname->st) != 0) {
5785                                 DEBUG(3, ("fstat of %s failed (%s)\n",
5786                                           fsp_fnum_dbg(fsp), strerror(errno)));
5787                                 reply_nterror(req,
5788                                         map_nt_error_from_unix(errno));
5789                                 return;
5790                         }
5791                         fileid = vfs_file_id_from_sbuf(conn, &smb_fname->st);
5792                         get_file_infos(fileid, fsp->name_hash, &delete_pending, &write_time_ts);
5793                 }
5794
5795         } else {
5796                 uint32_t name_hash;
5797                 char *fname = NULL;
5798                 uint32_t ucf_flags = ucf_flags_from_smb_request(req);
5799
5800                 /* qpathinfo */
5801                 if (total_params < 7) {
5802                         reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
5803                         return;
5804                 }
5805
5806                 info_level = SVAL(params,0);
5807
5808                 DEBUG(3,("call_trans2qfilepathinfo: TRANSACT2_QPATHINFO: level = %d\n", info_level));
5809
5810                 if (INFO_LEVEL_IS_UNIX(info_level)) {
5811                         if (!lp_unix_extensions()) {
5812                                 reply_nterror(req, NT_STATUS_INVALID_LEVEL);
5813                                 return;
5814                         }
5815                         if (info_level == SMB_QUERY_FILE_UNIX_BASIC ||
5816                                         info_level == SMB_QUERY_FILE_UNIX_INFO2 ||
5817                                         info_level == SMB_QUERY_FILE_UNIX_LINK ||
5818                                         req->posix_pathnames) {
5819                                 ucf_flags |= UCF_UNIX_NAME_LOOKUP;
5820                         }
5821                 }
5822
5823                 if (req->posix_pathnames) {
5824                         srvstr_get_path_posix(req,
5825                                 params,
5826                                 req->flags2,
5827                                 &fname,
5828                                 &params[6],
5829                                 total_params - 6,
5830                                 STR_TERMINATE,
5831                                 &status);
5832                 } else {
5833                         srvstr_get_path(req,
5834                                 params,
5835                                 req->flags2,
5836                                 &fname,
5837                                 &params[6],
5838                                 total_params - 6,
5839                                 STR_TERMINATE,
5840                                 &status);
5841                 }
5842                 if (!NT_STATUS_IS_OK(status)) {
5843                         reply_nterror(req, status);
5844                         return;
5845                 }
5846
5847                 status = filename_convert(req,
5848                                         conn,
5849                                         fname,
5850                                         ucf_flags,
5851                                         NULL,
5852                                         &smb_fname);
5853                 if (!NT_STATUS_IS_OK(status)) {
5854                         if (NT_STATUS_EQUAL(status,NT_STATUS_PATH_NOT_COVERED)) {
5855                                 reply_botherror(req,
5856                                                 NT_STATUS_PATH_NOT_COVERED,
5857                                                 ERRSRV, ERRbadpath);
5858                                 return;
5859                         }
5860                         reply_nterror(req, status);
5861                         return;
5862                 }
5863
5864                 /* If this is a stream, check if there is a delete_pending. */
5865                 if ((conn->fs_capabilities & FILE_NAMED_STREAMS)
5866                     && is_ntfs_stream_smb_fname(smb_fname)) {
5867                         struct smb_filename *smb_fname_base;
5868
5869                         /* Create an smb_filename with stream_name == NULL. */
5870                         smb_fname_base = synthetic_smb_fname(
5871                                                 talloc_tos(),
5872                                                 smb_fname->base_name,
5873                                                 NULL,
5874                                                 NULL,
5875                                                 smb_fname->flags);
5876                         if (smb_fname_base == NULL) {
5877                                 reply_nterror(req, NT_STATUS_NO_MEMORY);
5878                                 return;
5879                         }
5880
5881                         if (INFO_LEVEL_IS_UNIX(info_level) || req->posix_pathnames) {
5882                                 /* Always do lstat for UNIX calls. */
5883                                 if (SMB_VFS_LSTAT(conn, smb_fname_base) != 0) {
5884                                         DEBUG(3,("call_trans2qfilepathinfo: "
5885                                                  "SMB_VFS_LSTAT of %s failed "
5886                                                  "(%s)\n",
5887                                                  smb_fname_str_dbg(smb_fname_base),
5888                                                  strerror(errno)));
5889                                         TALLOC_FREE(smb_fname_base);
5890                                         reply_nterror(req,
5891                                                 map_nt_error_from_unix(errno));
5892                                         return;
5893                                 }
5894                         } else {
5895                                 if (SMB_VFS_STAT(conn, smb_fname_base) != 0) {
5896                                         DEBUG(3,("call_trans2qfilepathinfo: "
5897                                                  "fileinfo of %s failed "
5898                                                  "(%s)\n",
5899                                                  smb_fname_str_dbg(smb_fname_base),
5900                                                  strerror(errno)));
5901                                         TALLOC_FREE(smb_fname_base);
5902                                         reply_nterror(req,
5903                                                 map_nt_error_from_unix(errno));
5904                                         return;
5905                                 }
5906                         }
5907
5908                         status = file_name_hash(conn,
5909                                         smb_fname_str_dbg(smb_fname_base),
5910                                         &name_hash);
5911                         if (!NT_STATUS_IS_OK(status)) {
5912                                 TALLOC_FREE(smb_fname_base);
5913                                 reply_nterror(req, status);
5914                                 return;
5915                         }
5916
5917                         fileid = vfs_file_id_from_sbuf(conn,
5918                                                        &smb_fname_base->st);
5919                         TALLOC_FREE(smb_fname_base);
5920                         get_file_infos(fileid, name_hash, &delete_pending, NULL);
5921                         if (delete_pending) {
5922                                 reply_nterror(req, NT_STATUS_DELETE_PENDING);
5923                                 return;
5924                         }
5925                 }
5926
5927                 if (INFO_LEVEL_IS_UNIX(info_level) || req->posix_pathnames) {
5928                         /* Always do lstat for UNIX calls. */
5929                         if (SMB_VFS_LSTAT(conn, smb_fname)) {
5930                                 DEBUG(3,("call_trans2qfilepathinfo: "
5931                                          "SMB_VFS_LSTAT of %s failed (%s)\n",
5932                                          smb_fname_str_dbg(smb_fname),
5933                                          strerror(errno)));
5934                                 reply_nterror(req,
5935                                         map_nt_error_from_unix(errno));
5936                                 return;
5937                         }
5938
5939                 } else {
5940                         if (SMB_VFS_STAT(conn, smb_fname) != 0) {
5941                                 DEBUG(3,("call_trans2qfilepathinfo: "
5942                                          "SMB_VFS_STAT of %s failed (%s)\n",
5943                                          smb_fname_str_dbg(smb_fname),
5944                                          strerror(errno)));
5945                                 reply_nterror(req,
5946                                         map_nt_error_from_unix(errno));
5947                                 return;
5948                         }
5949                 }
5950
5951                 status = file_name_hash(conn,
5952                                 smb_fname_str_dbg(smb_fname),
5953                                 &name_hash);
5954                 if (!NT_STATUS_IS_OK(status)) {
5955                         reply_nterror(req, status);
5956                         return;
5957                 }
5958
5959                 fileid = vfs_file_id_from_sbuf(conn, &smb_fname->st);
5960                 get_file_infos(fileid, name_hash, &delete_pending, &write_time_ts);
5961                 if (delete_pending) {
5962                         reply_nterror(req, NT_STATUS_DELETE_PENDING);
5963                         return;
5964                 }
5965         }
5966
5967         DEBUG(3,("call_trans2qfilepathinfo %s (%s) level=%d call=%d "
5968                  "total_data=%d\n", smb_fname_str_dbg(smb_fname),
5969                  fsp_fnum_dbg(fsp),
5970                  info_level,tran_call,total_data));
5971
5972         /* Pull out any data sent here before we realloc. */
5973         switch (info_level) {
5974                 case SMB_INFO_QUERY_EAS_FROM_LIST:
5975                 {
5976                         /* Pull any EA list from the data portion. */
5977                         uint32_t ea_size;
5978
5979                         if (total_data < 4) {
5980                                 reply_nterror(
5981                                         req, NT_STATUS_INVALID_PARAMETER);
5982                                 return;
5983                         }
5984                         ea_size = IVAL(pdata,0);
5985
5986                         if (total_data > 0 && ea_size != total_data) {
5987                                 DEBUG(4,("call_trans2qfilepathinfo: Rejecting EA request with incorrect \
5988 total_data=%u (should be %u)\n", (unsigned int)total_data, (unsigned int)IVAL(pdata,0) ));
5989                                 reply_nterror(
5990                                         req, NT_STATUS_INVALID_PARAMETER);
5991                                 return;
5992                         }
5993
5994                         if (!lp_ea_support(SNUM(conn))) {
5995                                 reply_nterror(req, NT_STATUS_EAS_NOT_SUPPORTED);
5996                                 return;
5997                         }
5998
5999                         /* Pull out the list of names. */
6000                         ea_list = read_ea_name_list(req, pdata + 4, ea_size - 4);
6001                         if (!ea_list) {
6002                                 reply_nterror(
6003                                         req, NT_STATUS_INVALID_PARAMETER);
6004                                 return;
6005                         }
6006                         break;
6007                 }
6008
6009                 case SMB_QUERY_POSIX_LOCK:
6010                 {
6011                         if (fsp == NULL || fsp->fh->fd == -1) {
6012                                 reply_nterror(req, NT_STATUS_INVALID_HANDLE);
6013                                 return;
6014                         }
6015
6016                         if (total_data != POSIX_LOCK_DATA_SIZE) {
6017                                 reply_nterror(
6018                                         req, NT_STATUS_INVALID_PARAMETER);
6019                                 return;
6020                         }
6021
6022                         /* Copy the lock range data. */
6023                         lock_data = (char *)talloc_memdup(
6024                                 req, pdata, total_data);
6025                         if (!lock_data) {
6026                                 reply_nterror(req, NT_STATUS_NO_MEMORY);
6027                                 return;
6028                         }
6029                         lock_data_count = total_data;
6030                 }
6031                 default:
6032                         break;
6033         }
6034
6035         *pparams = (char *)SMB_REALLOC(*pparams,2);
6036         if (*pparams == NULL) {
6037                 reply_nterror(req, NT_STATUS_NO_MEMORY);
6038                 return;
6039         }
6040         params = *pparams;
6041         SSVAL(params,0,0);
6042
6043         /*
6044          * draft-leach-cifs-v1-spec-02.txt
6045          * 4.2.14 TRANS2_QUERY_PATH_INFORMATION: Get File Attributes given Path
6046          * says:
6047          *
6048          *  The requested information is placed in the Data portion of the
6049          *  transaction response. For the information levels greater than 0x100,
6050          *  the transaction response has 1 parameter word which should be
6051          *  ignored by the client.
6052          *
6053          * However Windows only follows this rule for the IS_NAME_VALID call.
6054          */
6055         switch (info_level) {
6056         case SMB_INFO_IS_NAME_VALID:
6057                 param_size = 0;
6058                 break;
6059         }
6060
6061         if ((info_level & 0xFF00) == 0xFF00) {
6062                 /*
6063                  * We use levels that start with 0xFF00
6064                  * internally to represent SMB2 specific levels
6065                  */
6066                 reply_nterror(req, NT_STATUS_INVALID_LEVEL);
6067                 return;
6068         }
6069
6070         status = smbd_do_qfilepathinfo(conn, req, info_level,
6071                                        fsp, smb_fname,
6072                                        delete_pending, write_time_ts,
6073                                        ea_list,
6074                                        lock_data_count, lock_data,
6075                                        req->flags2, max_data_bytes,
6076                                        &fixed_portion,
6077                                        ppdata, &data_size);
6078         if (!NT_STATUS_IS_OK(status)) {
6079                 reply_nterror(req, status);
6080                 return;
6081         }
6082         if (fixed_portion > max_data_bytes) {
6083                 reply_nterror(req, NT_STATUS_INFO_LENGTH_MISMATCH);
6084                 return;
6085         }
6086
6087         send_trans2_replies(conn, req, NT_STATUS_OK, params, param_size, *ppdata, data_size,
6088                             max_data_bytes);
6089
6090         return;
6091 }
6092
6093 /****************************************************************************
6094  Set a hard link (called by UNIX extensions and by NT rename with HARD link
6095  code.
6096 ****************************************************************************/
6097
6098 NTSTATUS hardlink_internals(TALLOC_CTX *ctx,
6099                 connection_struct *conn,
6100                 struct smb_request *req,
6101                 bool overwrite_if_exists,
6102                 const struct smb_filename *smb_fname_old,
6103                 struct smb_filename *smb_fname_new)
6104 {
6105         NTSTATUS status = NT_STATUS_OK;
6106
6107         /* source must already exist. */
6108         if (!VALID_STAT(smb_fname_old->st)) {
6109                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
6110         }
6111
6112         if (VALID_STAT(smb_fname_new->st)) {
6113                 if (overwrite_if_exists) {
6114                         if (S_ISDIR(smb_fname_new->st.st_ex_mode)) {
6115                                 return NT_STATUS_FILE_IS_A_DIRECTORY;
6116                         }
6117                         status = unlink_internals(conn,
6118                                                 req,
6119                                                 FILE_ATTRIBUTE_NORMAL,
6120                                                 smb_fname_new,
6121                                                 false);
6122                         if (!NT_STATUS_IS_OK(status)) {
6123                                 return status;
6124                         }
6125                 } else {
6126                         /* Disallow if newname already exists. */
6127                         return NT_STATUS_OBJECT_NAME_COLLISION;
6128                 }
6129         }
6130
6131         /* No links from a directory. */
6132         if (S_ISDIR(smb_fname_old->st.st_ex_mode)) {
6133                 return NT_STATUS_FILE_IS_A_DIRECTORY;
6134         }
6135
6136         /* Setting a hardlink to/from a stream isn't currently supported. */
6137         if (is_ntfs_stream_smb_fname(smb_fname_old) ||
6138             is_ntfs_stream_smb_fname(smb_fname_new)) {
6139                 return NT_STATUS_INVALID_PARAMETER;
6140         }
6141
6142         DEBUG(10,("hardlink_internals: doing hard link %s -> %s\n",
6143                   smb_fname_old->base_name, smb_fname_new->base_name));
6144
6145         if (SMB_VFS_LINK(conn, smb_fname_old, smb_fname_new) != 0) {
6146                 status = map_nt_error_from_unix(errno);
6147                 DEBUG(3,("hardlink_internals: Error %s hard link %s -> %s\n",
6148                          nt_errstr(status), smb_fname_old->base_name,
6149                          smb_fname_new->base_name));
6150         }
6151         return status;
6152 }
6153
6154 /****************************************************************************
6155  Deal with setting the time from any of the setfilepathinfo functions.
6156  NOTE !!!! The check for FILE_WRITE_ATTRIBUTES access must be done *before*
6157  calling this function.
6158 ****************************************************************************/
6159
6160 NTSTATUS smb_set_file_time(connection_struct *conn,
6161                            files_struct *fsp,
6162                            const struct smb_filename *smb_fname,
6163                            struct smb_file_time *ft,
6164                            bool setting_write_time)
6165 {
6166         struct smb_filename smb_fname_base;
6167         uint32_t action =
6168                 FILE_NOTIFY_CHANGE_LAST_ACCESS
6169                 |FILE_NOTIFY_CHANGE_LAST_WRITE
6170                 |FILE_NOTIFY_CHANGE_CREATION;
6171
6172         if (!VALID_STAT(smb_fname->st)) {
6173                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
6174         }
6175
6176         /* get some defaults (no modifications) if any info is zero or -1. */
6177         if (null_timespec(ft->create_time)) {
6178                 action &= ~FILE_NOTIFY_CHANGE_CREATION;
6179         }
6180
6181         if (null_timespec(ft->atime)) {
6182                 action &= ~FILE_NOTIFY_CHANGE_LAST_ACCESS;
6183         }
6184
6185         if (null_timespec(ft->mtime)) {
6186                 action &= ~FILE_NOTIFY_CHANGE_LAST_WRITE;
6187         }
6188
6189         if (!setting_write_time) {
6190                 /* ft->mtime comes from change time, not write time. */
6191                 action &= ~FILE_NOTIFY_CHANGE_LAST_WRITE;
6192         }
6193
6194         /* Ensure the resolution is the correct for
6195          * what we can store on this filesystem. */
6196
6197         round_timespec(conn->ts_res, &ft->create_time);
6198         round_timespec(conn->ts_res, &ft->ctime);
6199         round_timespec(conn->ts_res, &ft->atime);
6200         round_timespec(conn->ts_res, &ft->mtime);
6201
6202         DEBUG(5,("smb_set_filetime: actime: %s\n ",
6203                 time_to_asc(convert_timespec_to_time_t(ft->atime))));
6204         DEBUG(5,("smb_set_filetime: modtime: %s\n ",
6205                 time_to_asc(convert_timespec_to_time_t(ft->mtime))));
6206         DEBUG(5,("smb_set_filetime: ctime: %s\n ",
6207                 time_to_asc(convert_timespec_to_time_t(ft->ctime))));
6208         DEBUG(5,("smb_set_file_time: createtime: %s\n ",
6209                 time_to_asc(convert_timespec_to_time_t(ft->create_time))));
6210
6211         if (setting_write_time) {
6212                 /*
6213                  * This was a Windows setfileinfo on an open file.
6214                  * NT does this a lot. We also need to
6215                  * set the time here, as it can be read by
6216                  * FindFirst/FindNext and with the patch for bug #2045
6217                  * in smbd/fileio.c it ensures that this timestamp is
6218                  * kept sticky even after a write. We save the request
6219                  * away and will set it on file close and after a write. JRA.
6220                  */
6221
6222                 DEBUG(10,("smb_set_file_time: setting pending modtime to %s\n",
6223                           time_to_asc(convert_timespec_to_time_t(ft->mtime))));
6224
6225                 if (fsp != NULL) {
6226                         if (fsp->base_fsp) {
6227                                 set_sticky_write_time_fsp(fsp->base_fsp,
6228                                                           ft->mtime);
6229                         } else {
6230                                 set_sticky_write_time_fsp(fsp, ft->mtime);
6231                         }
6232                 } else {
6233                         set_sticky_write_time_path(
6234                                 vfs_file_id_from_sbuf(conn, &smb_fname->st),
6235                                 ft->mtime);
6236                 }
6237         }
6238
6239         DEBUG(10,("smb_set_file_time: setting utimes to modified values.\n"));
6240
6241         /* Always call ntimes on the base, even if a stream was passed in. */
6242         smb_fname_base = *smb_fname;
6243         smb_fname_base.stream_name = NULL;
6244
6245         if(file_ntimes(conn, &smb_fname_base, ft)!=0) {
6246                 return map_nt_error_from_unix(errno);
6247         }
6248
6249         notify_fname(conn, NOTIFY_ACTION_MODIFIED, action,
6250                      smb_fname->base_name);
6251         return NT_STATUS_OK;
6252 }
6253
6254 /****************************************************************************
6255  Deal with setting the dosmode from any of the setfilepathinfo functions.
6256  NB. The check for FILE_WRITE_ATTRIBUTES access on this path must have been
6257  done before calling this function.
6258 ****************************************************************************/
6259
6260 static NTSTATUS smb_set_file_dosmode(connection_struct *conn,
6261                                      const struct smb_filename *smb_fname,
6262                                      uint32_t dosmode)
6263 {
6264         struct smb_filename *smb_fname_base;
6265         NTSTATUS status;
6266
6267         if (!VALID_STAT(smb_fname->st)) {
6268                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
6269         }
6270
6271         /* Always operate on the base_name, even if a stream was passed in. */
6272         smb_fname_base = synthetic_smb_fname(talloc_tos(),
6273                                         smb_fname->base_name,
6274                                         NULL,
6275                                         &smb_fname->st,
6276                                         smb_fname->flags);
6277         if (smb_fname_base == NULL) {
6278                 return NT_STATUS_NO_MEMORY;
6279         }
6280
6281         if (dosmode) {
6282                 if (S_ISDIR(smb_fname_base->st.st_ex_mode)) {
6283                         dosmode |= FILE_ATTRIBUTE_DIRECTORY;
6284                 } else {
6285                         dosmode &= ~FILE_ATTRIBUTE_DIRECTORY;
6286                 }
6287         }
6288
6289         DEBUG(6,("smb_set_file_dosmode: dosmode: 0x%x\n", (unsigned int)dosmode));
6290
6291         /* check the mode isn't different, before changing it */
6292         if ((dosmode != 0) && (dosmode != dos_mode(conn, smb_fname_base))) {
6293                 DEBUG(10,("smb_set_file_dosmode: file %s : setting dos mode "
6294                           "0x%x\n", smb_fname_str_dbg(smb_fname_base),
6295                           (unsigned int)dosmode));
6296
6297                 if(file_set_dosmode(conn, smb_fname_base, dosmode, NULL,
6298                                     false)) {
6299                         DEBUG(2,("smb_set_file_dosmode: file_set_dosmode of "
6300                                  "%s failed (%s)\n",
6301                                  smb_fname_str_dbg(smb_fname_base),
6302                                  strerror(errno)));
6303                         status = map_nt_error_from_unix(errno);
6304                         goto out;
6305                 }
6306         }
6307         status = NT_STATUS_OK;
6308  out:
6309         TALLOC_FREE(smb_fname_base);
6310         return status;
6311 }
6312
6313 /****************************************************************************
6314  Deal with setting the size from any of the setfilepathinfo functions.
6315 ****************************************************************************/
6316
6317 static NTSTATUS smb_set_file_size(connection_struct *conn,
6318                                   struct smb_request *req,
6319                                   files_struct *fsp,
6320                                   const struct smb_filename *smb_fname,
6321                                   const SMB_STRUCT_STAT *psbuf,
6322                                   off_t size,
6323                                   bool fail_after_createfile)
6324 {
6325         NTSTATUS status = NT_STATUS_OK;
6326         struct smb_filename *smb_fname_tmp = NULL;
6327         files_struct *new_fsp = NULL;
6328
6329         if (!VALID_STAT(*psbuf)) {
6330                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
6331         }
6332
6333         DEBUG(6,("smb_set_file_size: size: %.0f ", (double)size));
6334
6335         if (size == get_file_size_stat(psbuf)) {
6336                 return NT_STATUS_OK;
6337         }
6338
6339         DEBUG(10,("smb_set_file_size: file %s : setting new size to %.0f\n",
6340                   smb_fname_str_dbg(smb_fname), (double)size));
6341
6342         if (fsp && fsp->fh->fd != -1) {
6343                 /* Handle based call. */
6344                 if (!(fsp->access_mask & FILE_WRITE_DATA)) {
6345                         return NT_STATUS_ACCESS_DENIED;
6346                 }
6347
6348                 if (vfs_set_filelen(fsp, size) == -1) {
6349                         return map_nt_error_from_unix(errno);
6350                 }
6351                 trigger_write_time_update_immediate(fsp);
6352                 return NT_STATUS_OK;
6353         }
6354
6355         smb_fname_tmp = cp_smb_filename(talloc_tos(), smb_fname);
6356         if (smb_fname_tmp == NULL) {
6357                 return NT_STATUS_NO_MEMORY;
6358         }
6359
6360         smb_fname_tmp->st = *psbuf;
6361
6362         status = SMB_VFS_CREATE_FILE(
6363                 conn,                                   /* conn */
6364                 req,                                    /* req */
6365                 0,                                      /* root_dir_fid */
6366                 smb_fname_tmp,                          /* fname */
6367                 FILE_WRITE_DATA,                        /* access_mask */
6368                 (FILE_SHARE_READ | FILE_SHARE_WRITE |   /* share_access */
6369                     FILE_SHARE_DELETE),
6370                 FILE_OPEN,                              /* create_disposition*/
6371                 0,                                      /* create_options */
6372                 FILE_ATTRIBUTE_NORMAL,                  /* file_attributes */
6373                 0,                                      /* oplock_request */
6374                 NULL,                                   /* lease */
6375                 0,                                      /* allocation_size */
6376                 0,                                      /* private_flags */
6377                 NULL,                                   /* sd */
6378                 NULL,                                   /* ea_list */
6379                 &new_fsp,                               /* result */
6380                 NULL,                                   /* pinfo */
6381                 NULL, NULL);                            /* create context */
6382
6383         TALLOC_FREE(smb_fname_tmp);
6384
6385         if (!NT_STATUS_IS_OK(status)) {
6386                 /* NB. We check for open_was_deferred in the caller. */
6387                 return status;
6388         }
6389
6390         /* See RAW-SFILEINFO-END-OF-FILE */
6391         if (fail_after_createfile) {
6392                 close_file(req, new_fsp,NORMAL_CLOSE);
6393                 return NT_STATUS_INVALID_LEVEL;
6394         }
6395
6396         if (vfs_set_filelen(new_fsp, size) == -1) {
6397                 status = map_nt_error_from_unix(errno);
6398                 close_file(req, new_fsp,NORMAL_CLOSE);
6399                 return status;
6400         }
6401
6402         trigger_write_time_update_immediate(new_fsp);
6403         close_file(req, new_fsp,NORMAL_CLOSE);
6404         return NT_STATUS_OK;
6405 }
6406
6407 /****************************************************************************
6408  Deal with SMB_INFO_SET_EA.
6409 ****************************************************************************/
6410
6411 static NTSTATUS smb_info_set_ea(connection_struct *conn,
6412                                 const char *pdata,
6413                                 int total_data,
6414                                 files_struct *fsp,
6415                                 const struct smb_filename *smb_fname)
6416 {
6417         struct ea_list *ea_list = NULL;
6418         TALLOC_CTX *ctx = NULL;
6419         NTSTATUS status = NT_STATUS_OK;
6420
6421         if (total_data < 10) {
6422
6423                 /* OS/2 workplace shell seems to send SET_EA requests of "null"
6424                    length. They seem to have no effect. Bug #3212. JRA */
6425
6426                 if ((total_data == 4) && (IVAL(pdata,0) == 4)) {
6427                         /* We're done. We only get EA info in this call. */
6428                         return NT_STATUS_OK;
6429                 }
6430
6431                 return NT_STATUS_INVALID_PARAMETER;
6432         }
6433
6434         if (IVAL(pdata,0) > total_data) {
6435                 DEBUG(10,("smb_info_set_ea: bad total data size (%u) > %u\n",
6436                         IVAL(pdata,0), (unsigned int)total_data));
6437                 return NT_STATUS_INVALID_PARAMETER;
6438         }
6439
6440         ctx = talloc_tos();
6441         ea_list = read_ea_list(ctx, pdata + 4, total_data - 4);
6442         if (!ea_list) {
6443                 return NT_STATUS_INVALID_PARAMETER;
6444         }
6445
6446         status = set_ea(conn, fsp, smb_fname, ea_list);
6447
6448         return status;
6449 }
6450
6451 /****************************************************************************
6452  Deal with SMB_FILE_FULL_EA_INFORMATION set.
6453 ****************************************************************************/
6454
6455 static NTSTATUS smb_set_file_full_ea_info(connection_struct *conn,
6456                                 const char *pdata,
6457                                 int total_data,
6458                                 files_struct *fsp)
6459 {
6460         struct ea_list *ea_list = NULL;
6461         NTSTATUS status;
6462
6463         if (!fsp) {
6464                 return NT_STATUS_INVALID_HANDLE;
6465         }
6466
6467         if (!lp_ea_support(SNUM(conn))) {
6468                 DEBUG(10, ("smb_set_file_full_ea_info - ea_len = %u but "
6469                         "EA's not supported.\n",
6470                         (unsigned int)total_data));
6471                 return NT_STATUS_EAS_NOT_SUPPORTED;
6472         }
6473
6474         if (total_data < 10) {
6475                 DEBUG(10, ("smb_set_file_full_ea_info - ea_len = %u "
6476                         "too small.\n",
6477                         (unsigned int)total_data));
6478                 return NT_STATUS_INVALID_PARAMETER;
6479         }
6480
6481         ea_list = read_nttrans_ea_list(talloc_tos(),
6482                                 pdata,
6483                                 total_data);
6484
6485         if (!ea_list) {
6486                 return NT_STATUS_INVALID_PARAMETER;
6487         }
6488
6489         status = set_ea(conn, fsp, fsp->fsp_name, ea_list);
6490
6491         DEBUG(10, ("smb_set_file_full_ea_info on file %s returned %s\n",
6492                 smb_fname_str_dbg(fsp->fsp_name),
6493                 nt_errstr(status) ));
6494
6495         return status;
6496 }
6497
6498
6499 /****************************************************************************
6500  Deal with SMB_SET_FILE_DISPOSITION_INFO.
6501 ****************************************************************************/
6502
6503 static NTSTATUS smb_set_file_disposition_info(connection_struct *conn,
6504                                 const char *pdata,
6505                                 int total_data,
6506                                 files_struct *fsp,
6507                                 struct smb_filename *smb_fname)
6508 {
6509         NTSTATUS status = NT_STATUS_OK;
6510         bool delete_on_close;
6511         uint32_t dosmode = 0;
6512
6513         if (total_data < 1) {
6514                 return NT_STATUS_INVALID_PARAMETER;
6515         }
6516
6517         if (fsp == NULL) {
6518                 return NT_STATUS_INVALID_HANDLE;
6519         }
6520
6521         delete_on_close = (CVAL(pdata,0) ? True : False);
6522         dosmode = dos_mode(conn, smb_fname);
6523
6524         DEBUG(10,("smb_set_file_disposition_info: file %s, dosmode = %u, "
6525                 "delete_on_close = %u\n",
6526                 smb_fname_str_dbg(smb_fname),
6527                 (unsigned int)dosmode,
6528                 (unsigned int)delete_on_close ));
6529
6530         if (delete_on_close) {
6531                 status = can_set_delete_on_close(fsp, dosmode);
6532                 if (!NT_STATUS_IS_OK(status)) {
6533                         return status;
6534                 }
6535         }
6536
6537         /* The set is across all open files on this dev/inode pair. */
6538         if (!set_delete_on_close(fsp, delete_on_close,
6539                                  conn->session_info->security_token,
6540                                  conn->session_info->unix_token)) {
6541                 return NT_STATUS_ACCESS_DENIED;
6542         }
6543         return NT_STATUS_OK;
6544 }
6545
6546 /****************************************************************************
6547  Deal with SMB_FILE_POSITION_INFORMATION.
6548 ****************************************************************************/
6549
6550 static NTSTATUS smb_file_position_information(connection_struct *conn,
6551                                 const char *pdata,
6552                                 int total_data,
6553                                 files_struct *fsp)
6554 {
6555         uint64_t position_information;
6556
6557         if (total_data < 8) {
6558                 return NT_STATUS_INVALID_PARAMETER;
6559         }
6560
6561         if (fsp == NULL) {
6562                 /* Ignore on pathname based set. */
6563                 return NT_STATUS_OK;
6564         }
6565
6566         position_information = (uint64_t)IVAL(pdata,0);
6567         position_information |= (((uint64_t)IVAL(pdata,4)) << 32);
6568
6569         DEBUG(10,("smb_file_position_information: Set file position "
6570                   "information for file %s to %.0f\n", fsp_str_dbg(fsp),
6571                   (double)position_information));
6572         fsp->fh->position_information = position_information;
6573         return NT_STATUS_OK;
6574 }
6575
6576 /****************************************************************************
6577  Deal with SMB_FILE_MODE_INFORMATION.
6578 ****************************************************************************/
6579
6580 static NTSTATUS smb_file_mode_information(connection_struct *conn,
6581                                 const char *pdata,
6582                                 int total_data)
6583 {
6584         uint32_t mode;
6585
6586         if (total_data < 4) {
6587                 return NT_STATUS_INVALID_PARAMETER;
6588         }
6589         mode = IVAL(pdata,0);
6590         if (mode != 0 && mode != 2 && mode != 4 && mode != 6) {
6591                 return NT_STATUS_INVALID_PARAMETER;
6592         }
6593         return NT_STATUS_OK;
6594 }
6595
6596 /****************************************************************************
6597  Deal with SMB_SET_FILE_UNIX_LINK (create a UNIX symlink).
6598 ****************************************************************************/
6599
6600 static NTSTATUS smb_set_file_unix_link(connection_struct *conn,
6601                                        struct smb_request *req,
6602                                        const char *pdata,
6603                                        int total_data,
6604                                        const struct smb_filename *new_smb_fname)
6605 {
6606         char *link_target = NULL;
6607         TALLOC_CTX *ctx = talloc_tos();
6608
6609         /* Set a symbolic link. */
6610         /* Don't allow this if follow links is false. */
6611
6612         if (total_data == 0) {
6613                 return NT_STATUS_INVALID_PARAMETER;
6614         }
6615
6616         if (!lp_follow_symlinks(SNUM(conn))) {
6617                 return NT_STATUS_ACCESS_DENIED;
6618         }
6619
6620         srvstr_pull_talloc(ctx, pdata, req->flags2, &link_target, pdata,
6621                     total_data, STR_TERMINATE);
6622
6623         if (!link_target) {
6624                 return NT_STATUS_INVALID_PARAMETER;
6625         }
6626
6627         DEBUG(10,("smb_set_file_unix_link: SMB_SET_FILE_UNIX_LINK doing symlink %s -> %s\n",
6628                         new_smb_fname->base_name, link_target ));
6629
6630         if (SMB_VFS_SYMLINK(conn,link_target,new_smb_fname) != 0) {
6631                 return map_nt_error_from_unix(errno);
6632         }
6633
6634         return NT_STATUS_OK;
6635 }
6636
6637 /****************************************************************************
6638  Deal with SMB_SET_FILE_UNIX_HLINK (create a UNIX hard link).
6639 ****************************************************************************/
6640
6641 static NTSTATUS smb_set_file_unix_hlink(connection_struct *conn,
6642                                         struct smb_request *req,
6643                                         const char *pdata, int total_data,
6644                                         struct smb_filename *smb_fname_new)
6645 {
6646         char *oldname = NULL;
6647         struct smb_filename *smb_fname_old = NULL;
6648         uint32_t ucf_flags = ucf_flags_from_smb_request(req);
6649         TALLOC_CTX *ctx = talloc_tos();
6650         NTSTATUS status = NT_STATUS_OK;
6651
6652         /* Set a hard link. */
6653         if (total_data == 0) {
6654                 return NT_STATUS_INVALID_PARAMETER;
6655         }
6656
6657         if (req->posix_pathnames) {
6658                 srvstr_get_path_posix(ctx,
6659                         pdata,
6660                         req->flags2,
6661                         &oldname,
6662                         pdata,
6663                         total_data,
6664                         STR_TERMINATE,
6665                         &status);
6666         } else {
6667                 srvstr_get_path(ctx,
6668                         pdata,
6669                         req->flags2,
6670                         &oldname,
6671                         pdata,
6672                         total_data,
6673                         STR_TERMINATE,
6674                         &status);
6675         }
6676         if (!NT_STATUS_IS_OK(status)) {
6677                 return status;
6678         }
6679
6680         DEBUG(10,("smb_set_file_unix_hlink: SMB_SET_FILE_UNIX_LINK doing hard link %s -> %s\n",
6681                 smb_fname_str_dbg(smb_fname_new), oldname));
6682
6683         status = filename_convert(ctx,
6684                                 conn,
6685                                 oldname,
6686                                 ucf_flags,
6687                                 NULL,
6688                                 &smb_fname_old);
6689         if (!NT_STATUS_IS_OK(status)) {
6690                 return status;
6691         }
6692
6693         return hardlink_internals(ctx, conn, req, false,
6694                         smb_fname_old, smb_fname_new);
6695 }
6696
6697 /****************************************************************************
6698  Deal with SMB2_FILE_RENAME_INFORMATION_INTERNAL
6699 ****************************************************************************/
6700
6701 static NTSTATUS smb2_file_rename_information(connection_struct *conn,
6702                                             struct smb_request *req,
6703                                             const char *pdata,
6704                                             int total_data,
6705                                             files_struct *fsp,
6706                                             struct smb_filename *smb_fname_src)
6707 {
6708         bool overwrite;
6709         uint32_t len;
6710         char *newname = NULL;
6711         struct smb_filename *smb_fname_dst = NULL;
6712         uint32_t ucf_flags = UCF_SAVE_LCOMP |
6713                 ucf_flags_from_smb_request(req);
6714         NTSTATUS status = NT_STATUS_OK;
6715         TALLOC_CTX *ctx = talloc_tos();
6716
6717         if (!fsp) {
6718                 return NT_STATUS_INVALID_HANDLE;
6719         }
6720
6721         if (total_data < 20) {
6722                 return NT_STATUS_INVALID_PARAMETER;
6723         }
6724
6725         overwrite = (CVAL(pdata,0) ? True : False);
6726         len = IVAL(pdata,16);
6727
6728         if (len > (total_data - 20) || (len == 0)) {
6729                 return NT_STATUS_INVALID_PARAMETER;
6730         }
6731
6732         if (req->posix_pathnames) {
6733                 srvstr_get_path_posix(ctx,
6734                                 pdata,
6735                                 req->flags2,
6736                                 &newname,
6737                                 &pdata[20],
6738                                 len,
6739                                 STR_TERMINATE,
6740                                 &status);
6741         } else {
6742                 srvstr_get_path(ctx,
6743                                 pdata,
6744                                 req->flags2,
6745                                 &newname,
6746                                 &pdata[20],
6747                                 len,
6748                                 STR_TERMINATE,
6749                                 &status);
6750         }
6751         if (!NT_STATUS_IS_OK(status)) {
6752                 return status;
6753         }
6754
6755         DEBUG(10,("smb2_file_rename_information: got name |%s|\n",
6756                                 newname));
6757
6758         status = filename_convert(ctx,
6759                                 conn,
6760                                 newname,
6761                                 ucf_flags,
6762                                 NULL,
6763                                 &smb_fname_dst);
6764         if (!NT_STATUS_IS_OK(status)) {
6765                 return status;
6766         }
6767
6768         if (fsp->base_fsp) {
6769                 /* newname must be a stream name. */
6770                 if (newname[0] != ':') {
6771                         return NT_STATUS_NOT_SUPPORTED;
6772                 }
6773
6774                 /* Create an smb_fname to call rename_internals_fsp() with. */
6775                 smb_fname_dst = synthetic_smb_fname(talloc_tos(),
6776                                         fsp->base_fsp->fsp_name->base_name,
6777                                         newname,
6778                                         NULL,
6779                                         fsp->base_fsp->fsp_name->flags);
6780                 if (smb_fname_dst == NULL) {
6781                         status = NT_STATUS_NO_MEMORY;
6782                         goto out;
6783                 }
6784
6785                 /*
6786                  * Set the original last component, since
6787                  * rename_internals_fsp() requires it.
6788                  */
6789                 smb_fname_dst->original_lcomp = talloc_strdup(smb_fname_dst,
6790                                                               newname);
6791                 if (smb_fname_dst->original_lcomp == NULL) {
6792                         status = NT_STATUS_NO_MEMORY;
6793                         goto out;
6794                 }
6795
6796         }
6797
6798         DEBUG(10,("smb2_file_rename_information: "
6799                   "SMB_FILE_RENAME_INFORMATION (%s) %s -> %s\n",
6800                   fsp_fnum_dbg(fsp), fsp_str_dbg(fsp),
6801                   smb_fname_str_dbg(smb_fname_dst)));
6802         status = rename_internals_fsp(conn, fsp, smb_fname_dst,
6803                                 (FILE_ATTRIBUTE_HIDDEN|FILE_ATTRIBUTE_SYSTEM),
6804                                 overwrite);
6805
6806  out:
6807         TALLOC_FREE(smb_fname_dst);
6808         return status;
6809 }
6810
6811 static NTSTATUS smb_file_link_information(connection_struct *conn,
6812                                             struct smb_request *req,
6813                                             const char *pdata,
6814                                             int total_data,
6815                                             files_struct *fsp,
6816                                             struct smb_filename *smb_fname_src)
6817 {
6818         bool overwrite;
6819         uint32_t len;
6820         char *newname = NULL;
6821         struct smb_filename *smb_fname_dst = NULL;
6822         NTSTATUS status = NT_STATUS_OK;
6823         uint32_t ucf_flags = UCF_SAVE_LCOMP |
6824                 ucf_flags_from_smb_request(req);
6825         TALLOC_CTX *ctx = talloc_tos();
6826
6827         if (!fsp) {
6828                 return NT_STATUS_INVALID_HANDLE;
6829         }
6830
6831         if (total_data < 20) {
6832                 return NT_STATUS_INVALID_PARAMETER;
6833         }
6834
6835         overwrite = (CVAL(pdata,0) ? true : false);
6836         len = IVAL(pdata,16);
6837
6838         if (len > (total_data - 20) || (len == 0)) {
6839                 return NT_STATUS_INVALID_PARAMETER;
6840         }
6841
6842         if (req->posix_pathnames) {
6843                 srvstr_get_path_posix(ctx,
6844                                 pdata,
6845                                 req->flags2,
6846                                 &newname,
6847                                 &pdata[20],
6848                                 len,
6849                                 STR_TERMINATE,
6850                                 &status);
6851         } else {
6852                 srvstr_get_path(ctx,
6853                                 pdata,
6854                                 req->flags2,
6855                                 &newname,
6856                                 &pdata[20],
6857                                 len,
6858                                 STR_TERMINATE,
6859                                 &status);
6860         }
6861         if (!NT_STATUS_IS_OK(status)) {
6862                 return status;
6863         }
6864
6865         DEBUG(10,("smb_file_link_information: got name |%s|\n",
6866                                 newname));
6867
6868         status = filename_convert(ctx,
6869                                 conn,
6870                                 newname,
6871                                 ucf_flags,
6872                                 NULL,
6873                                 &smb_fname_dst);
6874         if (!NT_STATUS_IS_OK(status)) {
6875                 return status;
6876         }
6877
6878         if (fsp->base_fsp) {
6879                 /* No stream names. */
6880                 return NT_STATUS_NOT_SUPPORTED;
6881         }
6882
6883         DEBUG(10,("smb_file_link_information: "
6884                   "SMB_FILE_LINK_INFORMATION (%s) %s -> %s\n",
6885                   fsp_fnum_dbg(fsp), fsp_str_dbg(fsp),
6886                   smb_fname_str_dbg(smb_fname_dst)));
6887         status = hardlink_internals(ctx,
6888                                 conn,
6889                                 req,
6890                                 overwrite,
6891                                 fsp->fsp_name,
6892                                 smb_fname_dst);
6893
6894         TALLOC_FREE(smb_fname_dst);
6895         return status;
6896 }
6897
6898 /****************************************************************************
6899  Deal with SMB_FILE_RENAME_INFORMATION.
6900 ****************************************************************************/
6901
6902 static NTSTATUS smb_file_rename_information(connection_struct *conn,
6903                                             struct smb_request *req,
6904                                             const char *pdata,
6905                                             int total_data,
6906                                             files_struct *fsp,
6907                                             struct smb_filename *smb_fname_src)
6908 {
6909         bool overwrite;
6910         uint32_t root_fid;
6911         uint32_t len;
6912         char *newname = NULL;
6913         struct smb_filename *smb_fname_dst = NULL;
6914         bool dest_has_wcard = False;
6915         NTSTATUS status = NT_STATUS_OK;
6916         char *p;
6917         TALLOC_CTX *ctx = talloc_tos();
6918
6919         if (total_data < 13) {
6920                 return NT_STATUS_INVALID_PARAMETER;
6921         }
6922
6923         overwrite = (CVAL(pdata,0) ? True : False);
6924         root_fid = IVAL(pdata,4);
6925         len = IVAL(pdata,8);
6926
6927         if (len > (total_data - 12) || (len == 0) || (root_fid != 0)) {
6928                 return NT_STATUS_INVALID_PARAMETER;
6929         }
6930
6931         if (req->posix_pathnames) {
6932                 srvstr_get_path_wcard_posix(ctx,
6933                                 pdata,
6934                                 req->flags2,
6935                                 &newname,
6936                                 &pdata[12],
6937                                 len,
6938                                 0,
6939                                 &status,
6940                                 &dest_has_wcard);
6941         } else {
6942                 srvstr_get_path_wcard(ctx,
6943                                 pdata,
6944                                 req->flags2,
6945                                 &newname,
6946                                 &pdata[12],
6947                                 len,
6948                                 0,
6949                                 &status,
6950                                 &dest_has_wcard);
6951         }
6952         if (!NT_STATUS_IS_OK(status)) {
6953                 return status;
6954         }
6955
6956         DEBUG(10,("smb_file_rename_information: got name |%s|\n",
6957                                 newname));
6958
6959         if (req->flags2 & FLAGS2_DFS_PATHNAMES) {
6960                 status = resolve_dfspath_wcard(ctx, conn,
6961                                        newname,
6962                                        UCF_COND_ALLOW_WCARD_LCOMP,
6963                                        !conn->sconn->using_smb2,
6964                                        &newname,
6965                                        &dest_has_wcard);
6966                 if (!NT_STATUS_IS_OK(status)) {
6967                         return status;
6968                 }
6969         }
6970
6971         /* Check the new name has no '/' characters. */
6972         if (strchr_m(newname, '/')) {
6973                 return NT_STATUS_NOT_SUPPORTED;
6974         }
6975
6976         if (fsp && fsp->base_fsp) {
6977                 /* newname must be a stream name. */
6978                 if (newname[0] != ':') {
6979                         return NT_STATUS_NOT_SUPPORTED;
6980                 }
6981
6982                 /* Create an smb_fname to call rename_internals_fsp() with. */
6983                 smb_fname_dst = synthetic_smb_fname(talloc_tos(),
6984                                         fsp->base_fsp->fsp_name->base_name,
6985                                         newname,
6986                                         NULL,
6987                                         fsp->base_fsp->fsp_name->flags);
6988                 if (smb_fname_dst == NULL) {
6989                         status = NT_STATUS_NO_MEMORY;
6990                         goto out;
6991                 }
6992
6993                 /*
6994                  * Set the original last component, since
6995                  * rename_internals_fsp() requires it.
6996                  */
6997                 smb_fname_dst->original_lcomp = talloc_strdup(smb_fname_dst,
6998                                                               newname);
6999                 if (smb_fname_dst->original_lcomp == NULL) {
7000                         status = NT_STATUS_NO_MEMORY;
7001                         goto out;
7002                 }
7003
7004         } else {
7005                 /*
7006                  * Build up an smb_fname_dst based on the filename passed in.
7007                  * We basically just strip off the last component, and put on
7008                  * the newname instead.
7009                  */
7010                 char *base_name = NULL;
7011                 uint32_t ucf_flags = UCF_SAVE_LCOMP |
7012                         ucf_flags_from_smb_request(req);
7013
7014                 if (dest_has_wcard) {
7015                         ucf_flags |= UCF_ALWAYS_ALLOW_WCARD_LCOMP;
7016                 }
7017
7018                 /* newname must *not* be a stream name. */
7019                 if (newname[0] == ':') {
7020                         return NT_STATUS_NOT_SUPPORTED;
7021                 }
7022
7023                 /*
7024                  * Strip off the last component (filename) of the path passed
7025                  * in.
7026                  */
7027                 base_name = talloc_strdup(ctx, smb_fname_src->base_name);
7028                 if (!base_name) {
7029                         return NT_STATUS_NO_MEMORY;
7030                 }
7031                 p = strrchr_m(base_name, '/');
7032                 if (p) {
7033                         p[1] = '\0';
7034                 } else {
7035                         base_name = talloc_strdup(ctx, "");
7036                         if (!base_name) {
7037                                 return NT_STATUS_NO_MEMORY;
7038                         }
7039                 }
7040                 /* Append the new name. */
7041                 base_name = talloc_asprintf_append(base_name,
7042                                 "%s",
7043                                 newname);
7044                 if (!base_name) {
7045                         return NT_STATUS_NO_MEMORY;
7046                 }
7047
7048                 status = unix_convert(ctx, conn, base_name, &smb_fname_dst,
7049                                         ucf_flags);
7050
7051                 /* If an error we expect this to be
7052                  * NT_STATUS_OBJECT_PATH_NOT_FOUND */
7053
7054                 if (!NT_STATUS_IS_OK(status)) {
7055                         if(!NT_STATUS_EQUAL(NT_STATUS_OBJECT_PATH_NOT_FOUND,
7056                                             status)) {
7057                                 goto out;
7058                         }
7059                         /* Create an smb_fname to call rename_internals_fsp() */
7060                         smb_fname_dst = synthetic_smb_fname(ctx,
7061                                                 base_name,
7062                                                 NULL,
7063                                                 NULL,
7064                                                 smb_fname_src->flags);
7065                         if (smb_fname_dst == NULL) {
7066                                 status = NT_STATUS_NO_MEMORY;
7067                                 goto out;
7068                         }
7069                 }
7070         }
7071
7072         if (fsp) {
7073                 DEBUG(10,("smb_file_rename_information: "
7074                           "SMB_FILE_RENAME_INFORMATION (%s) %s -> %s\n",
7075                           fsp_fnum_dbg(fsp), fsp_str_dbg(fsp),
7076                           smb_fname_str_dbg(smb_fname_dst)));
7077                 status = rename_internals_fsp(conn, fsp, smb_fname_dst, 0,
7078                                               overwrite);
7079         } else {
7080                 DEBUG(10,("smb_file_rename_information: "
7081                           "SMB_FILE_RENAME_INFORMATION %s -> %s\n",
7082                           smb_fname_str_dbg(smb_fname_src),
7083                           smb_fname_str_dbg(smb_fname_dst)));
7084                 status = rename_internals(ctx, conn, req, smb_fname_src,
7085                                           smb_fname_dst, 0, overwrite, false,
7086                                           dest_has_wcard,
7087                                           FILE_WRITE_ATTRIBUTES);
7088         }
7089  out:
7090         TALLOC_FREE(smb_fname_dst);
7091         return status;
7092 }
7093
7094 /****************************************************************************
7095  Deal with SMB_SET_POSIX_ACL.
7096 ****************************************************************************/
7097
7098 #if defined(HAVE_POSIX_ACLS)
7099 static NTSTATUS smb_set_posix_acl(connection_struct *conn,
7100                                 const char *pdata,
7101                                 int total_data,
7102                                 files_struct *fsp,
7103                                 const struct smb_filename *smb_fname)
7104 {
7105         uint16_t posix_acl_version;
7106         uint16_t num_file_acls;
7107         uint16_t num_def_acls;
7108         bool valid_file_acls = True;
7109         bool valid_def_acls = True;
7110         NTSTATUS status;
7111
7112         if (total_data < SMB_POSIX_ACL_HEADER_SIZE) {
7113                 return NT_STATUS_INVALID_PARAMETER;
7114         }
7115         posix_acl_version = SVAL(pdata,0);
7116         num_file_acls = SVAL(pdata,2);
7117         num_def_acls = SVAL(pdata,4);
7118
7119         if (num_file_acls == SMB_POSIX_IGNORE_ACE_ENTRIES) {
7120                 valid_file_acls = False;
7121                 num_file_acls = 0;
7122         }
7123
7124         if (num_def_acls == SMB_POSIX_IGNORE_ACE_ENTRIES) {
7125                 valid_def_acls = False;
7126                 num_def_acls = 0;
7127         }
7128
7129         if (posix_acl_version != SMB_POSIX_ACL_VERSION) {
7130                 return NT_STATUS_INVALID_PARAMETER;
7131         }
7132
7133         if (total_data < SMB_POSIX_ACL_HEADER_SIZE +
7134                         (num_file_acls+num_def_acls)*SMB_POSIX_ACL_ENTRY_SIZE) {
7135                 return NT_STATUS_INVALID_PARAMETER;
7136         }
7137
7138         status = refuse_symlink(conn, fsp, smb_fname);
7139         if (!NT_STATUS_IS_OK(status)) {
7140                 return status;
7141         }
7142
7143         DEBUG(10,("smb_set_posix_acl: file %s num_file_acls = %u, num_def_acls = %u\n",
7144                 smb_fname ? smb_fname_str_dbg(smb_fname) : fsp_str_dbg(fsp),
7145                 (unsigned int)num_file_acls,
7146                 (unsigned int)num_def_acls));
7147
7148         if (valid_file_acls && !set_unix_posix_acl(conn, fsp,
7149                 smb_fname, num_file_acls,
7150                 pdata + SMB_POSIX_ACL_HEADER_SIZE)) {
7151                 return map_nt_error_from_unix(errno);
7152         }
7153
7154         if (valid_def_acls && !set_unix_posix_default_acl(conn,
7155                 smb_fname, num_def_acls,
7156                 pdata + SMB_POSIX_ACL_HEADER_SIZE +
7157                 (num_file_acls*SMB_POSIX_ACL_ENTRY_SIZE))) {
7158                 return map_nt_error_from_unix(errno);
7159         }
7160         return NT_STATUS_OK;
7161 }
7162 #endif
7163
7164 /****************************************************************************
7165  Deal with SMB_SET_POSIX_LOCK.
7166 ****************************************************************************/
7167
7168 static NTSTATUS smb_set_posix_lock(connection_struct *conn,
7169                                 struct smb_request *req,
7170                                 const char *pdata,
7171                                 int total_data,
7172                                 files_struct *fsp)
7173 {
7174         uint64_t count;
7175         uint64_t offset;
7176         uint64_t smblctx;
7177         bool blocking_lock = False;
7178         enum brl_type lock_type;
7179
7180         NTSTATUS status = NT_STATUS_OK;
7181
7182         if (fsp == NULL || fsp->fh->fd == -1) {
7183                 return NT_STATUS_INVALID_HANDLE;
7184         }
7185
7186         if (total_data != POSIX_LOCK_DATA_SIZE) {
7187                 return NT_STATUS_INVALID_PARAMETER;
7188         }
7189
7190         switch (SVAL(pdata, POSIX_LOCK_TYPE_OFFSET)) {
7191                 case POSIX_LOCK_TYPE_READ:
7192                         lock_type = READ_LOCK;
7193                         break;
7194                 case POSIX_LOCK_TYPE_WRITE:
7195                         /* Return the right POSIX-mappable error code for files opened read-only. */
7196                         if (!fsp->can_write) {
7197                                 return NT_STATUS_INVALID_HANDLE;
7198                         }
7199                         lock_type = WRITE_LOCK;
7200                         break;
7201                 case POSIX_LOCK_TYPE_UNLOCK:
7202                         lock_type = UNLOCK_LOCK;
7203                         break;
7204                 default:
7205                         return NT_STATUS_INVALID_PARAMETER;
7206         }
7207
7208         if (SVAL(pdata,POSIX_LOCK_FLAGS_OFFSET) == POSIX_LOCK_FLAG_NOWAIT) {
7209                 blocking_lock = False;
7210         } else if (SVAL(pdata,POSIX_LOCK_FLAGS_OFFSET) == POSIX_LOCK_FLAG_WAIT) {
7211                 blocking_lock = True;
7212         } else {
7213                 return NT_STATUS_INVALID_PARAMETER;
7214         }
7215
7216         if (!lp_blocking_locks(SNUM(conn))) {
7217                 blocking_lock = False;
7218         }
7219
7220         smblctx = (uint64_t)IVAL(pdata, POSIX_LOCK_PID_OFFSET);
7221         offset = (((uint64_t) IVAL(pdata,(POSIX_LOCK_START_OFFSET+4))) << 32) |
7222                         ((uint64_t) IVAL(pdata,POSIX_LOCK_START_OFFSET));
7223         count = (((uint64_t) IVAL(pdata,(POSIX_LOCK_LEN_OFFSET+4))) << 32) |
7224                         ((uint64_t) IVAL(pdata,POSIX_LOCK_LEN_OFFSET));
7225
7226         DEBUG(10,("smb_set_posix_lock: file %s, lock_type = %u,"
7227                         "smblctx = %llu, count = %.0f, offset = %.0f\n",
7228                 fsp_str_dbg(fsp),
7229                 (unsigned int)lock_type,
7230                 (unsigned long long)smblctx,
7231                 (double)count,
7232                 (double)offset ));
7233
7234         if (lock_type == UNLOCK_LOCK) {
7235                 status = do_unlock(req->sconn->msg_ctx,
7236                                 fsp,
7237                                 smblctx,
7238                                 count,
7239                                 offset,
7240                                 POSIX_LOCK);
7241         } else {
7242                 uint64_t block_smblctx;
7243
7244                 struct byte_range_lock *br_lck = do_lock(req->sconn->msg_ctx,
7245                                                         fsp,
7246                                                         smblctx,
7247                                                         count,
7248                                                         offset,
7249                                                         lock_type,
7250                                                         POSIX_LOCK,
7251                                                         blocking_lock,
7252                                                         &status,
7253                                                         &block_smblctx);
7254
7255                 if (br_lck && blocking_lock && ERROR_WAS_LOCK_DENIED(status)) {
7256                         /*
7257                          * A blocking lock was requested. Package up
7258                          * this smb into a queued request and push it
7259                          * onto the blocking lock queue.
7260                          */
7261                         if(push_blocking_lock_request(br_lck,
7262                                                 req,
7263                                                 fsp,
7264                                                 -1, /* infinite timeout. */
7265                                                 0,
7266                                                 smblctx,
7267                                                 lock_type,
7268                                                 POSIX_LOCK,
7269                                                 offset,
7270                                                 count,
7271                                                 block_smblctx)) {
7272                                 TALLOC_FREE(br_lck);
7273                                 return status;
7274                         }
7275                 }
7276                 TALLOC_FREE(br_lck);
7277         }
7278
7279         return status;
7280 }
7281
7282 /****************************************************************************
7283  Deal with SMB_SET_FILE_BASIC_INFO.
7284 ****************************************************************************/
7285
7286 static NTSTATUS smb_set_file_basic_info(connection_struct *conn,
7287                                         const char *pdata,
7288                                         int total_data,
7289                                         files_struct *fsp,
7290                                         const struct smb_filename *smb_fname)
7291 {
7292         /* Patch to do this correctly from Paul Eggert <eggert@twinsun.com>. */
7293         struct smb_file_time ft;
7294         uint32_t dosmode = 0;
7295         NTSTATUS status = NT_STATUS_OK;
7296
7297         ZERO_STRUCT(ft);
7298
7299         if (total_data < 36) {
7300                 return NT_STATUS_INVALID_PARAMETER;
7301         }
7302
7303         status = check_access(conn, fsp, smb_fname, FILE_WRITE_ATTRIBUTES);
7304         if (!NT_STATUS_IS_OK(status)) {
7305                 return status;
7306         }
7307
7308         /* Set the attributes */
7309         dosmode = IVAL(pdata,32);
7310         status = smb_set_file_dosmode(conn, smb_fname, dosmode);
7311         if (!NT_STATUS_IS_OK(status)) {
7312                 return status;
7313         }
7314
7315         /* create time */
7316         ft.create_time = interpret_long_date(pdata);
7317
7318         /* access time */
7319         ft.atime = interpret_long_date(pdata+8);
7320
7321         /* write time. */
7322         ft.mtime = interpret_long_date(pdata+16);
7323
7324         /* change time. */
7325         ft.ctime = interpret_long_date(pdata+24);
7326
7327         DEBUG(10, ("smb_set_file_basic_info: file %s\n",
7328                    smb_fname_str_dbg(smb_fname)));
7329
7330         return smb_set_file_time(conn, fsp, smb_fname, &ft,
7331                                  true);
7332 }
7333
7334 /****************************************************************************
7335  Deal with SMB_INFO_STANDARD.
7336 ****************************************************************************/
7337
7338 static NTSTATUS smb_set_info_standard(connection_struct *conn,
7339                                         const char *pdata,
7340                                         int total_data,
7341                                         files_struct *fsp,
7342                                         const struct smb_filename *smb_fname)
7343 {
7344         NTSTATUS status;
7345         struct smb_file_time ft;
7346
7347         ZERO_STRUCT(ft);
7348
7349         if (total_data < 12) {
7350                 return NT_STATUS_INVALID_PARAMETER;
7351         }
7352
7353         /* create time */
7354         ft.create_time = convert_time_t_to_timespec(srv_make_unix_date2(pdata));
7355         /* access time */
7356         ft.atime = convert_time_t_to_timespec(srv_make_unix_date2(pdata+4));
7357         /* write time */
7358         ft.mtime = convert_time_t_to_timespec(srv_make_unix_date2(pdata+8));
7359
7360         DEBUG(10,("smb_set_info_standard: file %s\n",
7361                 smb_fname_str_dbg(smb_fname)));
7362
7363         status = check_access(conn, fsp, smb_fname, FILE_WRITE_ATTRIBUTES);
7364         if (!NT_STATUS_IS_OK(status)) {
7365                 return status;
7366         }
7367
7368         return smb_set_file_time(conn,
7369                                 fsp,
7370                                 smb_fname,
7371                                 &ft,
7372                                 true);
7373 }
7374
7375 /****************************************************************************
7376  Deal with SMB_SET_FILE_ALLOCATION_INFO.
7377 ****************************************************************************/
7378
7379 static NTSTATUS smb_set_file_allocation_info(connection_struct *conn,
7380                                              struct smb_request *req,
7381                                         const char *pdata,
7382                                         int total_data,
7383                                         files_struct *fsp,
7384                                         struct smb_filename *smb_fname)
7385 {
7386         uint64_t allocation_size = 0;
7387         NTSTATUS status = NT_STATUS_OK;
7388         files_struct *new_fsp = NULL;
7389
7390         if (!VALID_STAT(smb_fname->st)) {
7391                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
7392         }
7393
7394         if (total_data < 8) {
7395                 return NT_STATUS_INVALID_PARAMETER;
7396         }
7397
7398         allocation_size = (uint64_t)IVAL(pdata,0);
7399         allocation_size |= (((uint64_t)IVAL(pdata,4)) << 32);
7400         DEBUG(10,("smb_set_file_allocation_info: Set file allocation info for "
7401                   "file %s to %.0f\n", smb_fname_str_dbg(smb_fname),
7402                   (double)allocation_size));
7403
7404         if (allocation_size) {
7405                 allocation_size = smb_roundup(conn, allocation_size);
7406         }
7407
7408         DEBUG(10,("smb_set_file_allocation_info: file %s : setting new "
7409                   "allocation size to %.0f\n", smb_fname_str_dbg(smb_fname),
7410                   (double)allocation_size));
7411
7412         if (fsp && fsp->fh->fd != -1) {
7413                 /* Open file handle. */
7414                 if (!(fsp->access_mask & FILE_WRITE_DATA)) {
7415                         return NT_STATUS_ACCESS_DENIED;
7416                 }
7417
7418                 /* Only change if needed. */
7419                 if (allocation_size != get_file_size_stat(&smb_fname->st)) {
7420                         if (vfs_allocate_file_space(fsp, allocation_size) == -1) {
7421                                 return map_nt_error_from_unix(errno);
7422                         }
7423                 }
7424                 /* But always update the time. */
7425                 /*
7426                  * This is equivalent to a write. Ensure it's seen immediately
7427                  * if there are no pending writes.
7428                  */
7429                 trigger_write_time_update_immediate(fsp);
7430                 return NT_STATUS_OK;
7431         }
7432
7433         /* Pathname or stat or directory file. */
7434         status = SMB_VFS_CREATE_FILE(
7435                 conn,                                   /* conn */
7436                 req,                                    /* req */
7437                 0,                                      /* root_dir_fid */
7438                 smb_fname,                              /* fname */
7439                 FILE_WRITE_DATA,                        /* access_mask */
7440                 (FILE_SHARE_READ | FILE_SHARE_WRITE |   /* share_access */
7441                     FILE_SHARE_DELETE),
7442                 FILE_OPEN,                              /* create_disposition*/
7443                 0,                                      /* create_options */
7444                 FILE_ATTRIBUTE_NORMAL,                  /* file_attributes */
7445                 0,                                      /* oplock_request */
7446                 NULL,                                   /* lease */
7447                 0,                                      /* allocation_size */
7448                 0,                                      /* private_flags */
7449                 NULL,                                   /* sd */
7450                 NULL,                                   /* ea_list */
7451                 &new_fsp,                               /* result */
7452                 NULL,                                   /* pinfo */
7453                 NULL, NULL);                            /* create context */
7454
7455         if (!NT_STATUS_IS_OK(status)) {
7456                 /* NB. We check for open_was_deferred in the caller. */
7457                 return status;
7458         }
7459
7460         /* Only change if needed. */
7461         if (allocation_size != get_file_size_stat(&smb_fname->st)) {
7462                 if (vfs_allocate_file_space(new_fsp, allocation_size) == -1) {
7463                         status = map_nt_error_from_unix(errno);
7464                         close_file(req, new_fsp, NORMAL_CLOSE);
7465                         return status;
7466                 }
7467         }
7468
7469         /* Changing the allocation size should set the last mod time. */
7470         /*
7471          * This is equivalent to a write. Ensure it's seen immediately
7472          * if there are no pending writes.
7473          */
7474         trigger_write_time_update_immediate(new_fsp);
7475         close_file(req, new_fsp, NORMAL_CLOSE);
7476         return NT_STATUS_OK;
7477 }
7478
7479 /****************************************************************************
7480  Deal with SMB_SET_FILE_END_OF_FILE_INFO.
7481 ****************************************************************************/
7482
7483 static NTSTATUS smb_set_file_end_of_file_info(connection_struct *conn,
7484                                               struct smb_request *req,
7485                                         const char *pdata,
7486                                         int total_data,
7487                                         files_struct *fsp,
7488                                         const struct smb_filename *smb_fname,
7489                                         bool fail_after_createfile)
7490 {
7491         off_t size;
7492
7493         if (total_data < 8) {
7494                 return NT_STATUS_INVALID_PARAMETER;
7495         }
7496
7497         size = IVAL(pdata,0);
7498         size |= (((off_t)IVAL(pdata,4)) << 32);
7499         DEBUG(10,("smb_set_file_end_of_file_info: Set end of file info for "
7500                   "file %s to %.0f\n", smb_fname_str_dbg(smb_fname),
7501                   (double)size));
7502
7503         return smb_set_file_size(conn, req,
7504                                 fsp,
7505                                 smb_fname,
7506                                 &smb_fname->st,
7507                                 size,
7508                                 fail_after_createfile);
7509 }
7510
7511 /****************************************************************************
7512  Allow a UNIX info mknod.
7513 ****************************************************************************/
7514
7515 static NTSTATUS smb_unix_mknod(connection_struct *conn,
7516                                         const char *pdata,
7517                                         int total_data,
7518                                         const struct smb_filename *smb_fname)
7519 {
7520         uint32_t file_type = IVAL(pdata,56);
7521 #if defined(HAVE_MAKEDEV)
7522         uint32_t dev_major = IVAL(pdata,60);
7523         uint32_t dev_minor = IVAL(pdata,68);
7524 #endif
7525         SMB_DEV_T dev = (SMB_DEV_T)0;
7526         uint32_t raw_unixmode = IVAL(pdata,84);
7527         NTSTATUS status;
7528         mode_t unixmode;
7529
7530         if (total_data < 100) {
7531                 return NT_STATUS_INVALID_PARAMETER;
7532         }
7533
7534         status = unix_perms_from_wire(conn, &smb_fname->st, raw_unixmode,
7535                                       PERM_NEW_FILE, &unixmode);
7536         if (!NT_STATUS_IS_OK(status)) {
7537                 return status;
7538         }
7539
7540 #if defined(HAVE_MAKEDEV)
7541         dev = makedev(dev_major, dev_minor);
7542 #endif
7543
7544         switch (file_type) {
7545 #if defined(S_IFIFO)
7546                 case UNIX_TYPE_FIFO:
7547                         unixmode |= S_IFIFO;
7548                         break;
7549 #endif
7550 #if defined(S_IFSOCK)
7551                 case UNIX_TYPE_SOCKET:
7552                         unixmode |= S_IFSOCK;
7553                         break;
7554 #endif
7555 #if defined(S_IFCHR)
7556                 case UNIX_TYPE_CHARDEV:
7557                         unixmode |= S_IFCHR;
7558                         break;
7559 #endif
7560 #if defined(S_IFBLK)
7561                 case UNIX_TYPE_BLKDEV:
7562                         unixmode |= S_IFBLK;
7563                         break;
7564 #endif
7565                 default:
7566                         return NT_STATUS_INVALID_PARAMETER;
7567         }
7568
7569         DEBUG(10,("smb_unix_mknod: SMB_SET_FILE_UNIX_BASIC doing mknod dev "
7570                   "%.0f mode 0%o for file %s\n", (double)dev,
7571                   (unsigned int)unixmode, smb_fname_str_dbg(smb_fname)));
7572
7573         /* Ok - do the mknod. */
7574         if (SMB_VFS_MKNOD(conn, smb_fname, unixmode, dev) != 0) {
7575                 return map_nt_error_from_unix(errno);
7576         }
7577
7578         /* If any of the other "set" calls fail we
7579          * don't want to end up with a half-constructed mknod.
7580          */
7581
7582         if (lp_inherit_permissions(SNUM(conn))) {
7583                 char *parent;
7584                 if (!parent_dirname(talloc_tos(), smb_fname->base_name,
7585                                     &parent, NULL)) {
7586                         return NT_STATUS_NO_MEMORY;
7587                 }
7588                 inherit_access_posix_acl(conn, parent, smb_fname,
7589                                          unixmode);
7590                 TALLOC_FREE(parent);
7591         }
7592
7593         return NT_STATUS_OK;
7594 }
7595
7596 /****************************************************************************
7597  Deal with SMB_SET_FILE_UNIX_BASIC.
7598 ****************************************************************************/
7599
7600 static NTSTATUS smb_set_file_unix_basic(connection_struct *conn,
7601                                         struct smb_request *req,
7602                                         const char *pdata,
7603                                         int total_data,
7604                                         files_struct *fsp,
7605                                         const struct smb_filename *smb_fname)
7606 {
7607         struct smb_file_time ft;
7608         uint32_t raw_unixmode;
7609         mode_t unixmode;
7610         off_t size = 0;
7611         uid_t set_owner = (uid_t)SMB_UID_NO_CHANGE;
7612         gid_t set_grp = (uid_t)SMB_GID_NO_CHANGE;
7613         NTSTATUS status = NT_STATUS_OK;
7614         bool delete_on_fail = False;
7615         enum perm_type ptype;
7616         files_struct *all_fsps = NULL;
7617         bool modify_mtime = true;
7618         struct file_id id;
7619         struct smb_filename *smb_fname_tmp = NULL;
7620         SMB_STRUCT_STAT sbuf;
7621
7622         ZERO_STRUCT(ft);
7623
7624         if (total_data < 100) {
7625                 return NT_STATUS_INVALID_PARAMETER;
7626         }
7627
7628         if(IVAL(pdata, 0) != SMB_SIZE_NO_CHANGE_LO &&
7629            IVAL(pdata, 4) != SMB_SIZE_NO_CHANGE_HI) {
7630                 size=IVAL(pdata,0); /* first 8 Bytes are size */
7631                 size |= (((off_t)IVAL(pdata,4)) << 32);
7632         }
7633
7634         ft.atime = interpret_long_date(pdata+24); /* access_time */
7635         ft.mtime = interpret_long_date(pdata+32); /* modification_time */
7636         set_owner = (uid_t)IVAL(pdata,40);
7637         set_grp = (gid_t)IVAL(pdata,48);
7638         raw_unixmode = IVAL(pdata,84);
7639
7640         if (VALID_STAT(smb_fname->st)) {
7641                 if (S_ISDIR(smb_fname->st.st_ex_mode)) {
7642                         ptype = PERM_EXISTING_DIR;
7643                 } else {
7644                         ptype = PERM_EXISTING_FILE;
7645                 }
7646         } else {
7647                 ptype = PERM_NEW_FILE;
7648         }
7649
7650         status = unix_perms_from_wire(conn, &smb_fname->st, raw_unixmode,
7651                                       ptype, &unixmode);
7652         if (!NT_STATUS_IS_OK(status)) {
7653                 return status;
7654         }
7655
7656         DEBUG(10,("smb_set_file_unix_basic: SMB_SET_FILE_UNIX_BASIC: name = "
7657                   "%s size = %.0f, uid = %u, gid = %u, raw perms = 0%o\n",
7658                   smb_fname_str_dbg(smb_fname), (double)size,
7659                   (unsigned int)set_owner, (unsigned int)set_grp,
7660                   (int)raw_unixmode));
7661
7662         sbuf = smb_fname->st;
7663
7664         if (!VALID_STAT(sbuf)) {
7665                 /*
7666                  * The only valid use of this is to create character and block
7667                  * devices, and named pipes. This is deprecated (IMHO) and
7668                  * a new info level should be used for mknod. JRA.
7669                  */
7670
7671                 status = smb_unix_mknod(conn,
7672                                         pdata,
7673                                         total_data,
7674                                         smb_fname);
7675                 if (!NT_STATUS_IS_OK(status)) {
7676                         return status;
7677                 }
7678
7679                 smb_fname_tmp = cp_smb_filename(talloc_tos(), smb_fname);
7680                 if (smb_fname_tmp == NULL) {
7681                         return NT_STATUS_NO_MEMORY;
7682                 }
7683
7684                 if (SMB_VFS_STAT(conn, smb_fname_tmp) != 0) {
7685                         status = map_nt_error_from_unix(errno);
7686                         TALLOC_FREE(smb_fname_tmp);
7687                         SMB_VFS_UNLINK(conn, smb_fname);
7688                         return status;
7689                 }
7690
7691                 sbuf = smb_fname_tmp->st;
7692                 smb_fname = smb_fname_tmp;
7693
7694                 /* Ensure we don't try and change anything else. */
7695                 raw_unixmode = SMB_MODE_NO_CHANGE;
7696                 size = get_file_size_stat(&sbuf);
7697                 ft.atime = sbuf.st_ex_atime;
7698                 ft.mtime = sbuf.st_ex_mtime;
7699                 /*
7700                  * We continue here as we might want to change the
7701                  * owner uid/gid.
7702                  */
7703                 delete_on_fail = True;
7704         }
7705
7706 #if 1
7707         /* Horrible backwards compatibility hack as an old server bug
7708          * allowed a CIFS client bug to remain unnoticed :-(. JRA.
7709          * */
7710
7711         if (!size) {
7712                 size = get_file_size_stat(&sbuf);
7713         }
7714 #endif
7715
7716         /*
7717          * Deal with the UNIX specific mode set.
7718          */
7719
7720         if (raw_unixmode != SMB_MODE_NO_CHANGE) {
7721                 int ret;
7722
7723                 DEBUG(10,("smb_set_file_unix_basic: SMB_SET_FILE_UNIX_BASIC "
7724                           "setting mode 0%o for file %s\n",
7725                           (unsigned int)unixmode,
7726                           smb_fname_str_dbg(smb_fname)));
7727                 if (fsp && fsp->fh->fd != -1) {
7728                         ret = SMB_VFS_FCHMOD(fsp, unixmode);
7729                 } else {
7730                         ret = SMB_VFS_CHMOD(conn, smb_fname, unixmode);
7731                 }
7732                 if (ret != 0) {
7733                         return map_nt_error_from_unix(errno);
7734                 }
7735         }
7736
7737         /*
7738          * Deal with the UNIX specific uid set.
7739          */
7740
7741         if ((set_owner != (uid_t)SMB_UID_NO_CHANGE) &&
7742             (sbuf.st_ex_uid != set_owner)) {
7743                 int ret;
7744
7745                 DEBUG(10,("smb_set_file_unix_basic: SMB_SET_FILE_UNIX_BASIC "
7746                           "changing owner %u for path %s\n",
7747                           (unsigned int)set_owner,
7748                           smb_fname_str_dbg(smb_fname)));
7749
7750                 if (fsp && fsp->fh->fd != -1) {
7751                         ret = SMB_VFS_FCHOWN(fsp, set_owner, (gid_t)-1);
7752                 } else {
7753                         /*
7754                          * UNIX extensions calls must always operate
7755                          * on symlinks.
7756                          */
7757                         ret = SMB_VFS_LCHOWN(conn, smb_fname,
7758                                              set_owner, (gid_t)-1);
7759                 }
7760
7761                 if (ret != 0) {
7762                         status = map_nt_error_from_unix(errno);
7763                         if (delete_on_fail) {
7764                                 SMB_VFS_UNLINK(conn, smb_fname);
7765                         }
7766                         return status;
7767                 }
7768         }
7769
7770         /*
7771          * Deal with the UNIX specific gid set.
7772          */
7773
7774         if ((set_grp != (uid_t)SMB_GID_NO_CHANGE) &&
7775             (sbuf.st_ex_gid != set_grp)) {
7776                 int ret;
7777
7778                 DEBUG(10,("smb_set_file_unix_basic: SMB_SET_FILE_UNIX_BASIC "
7779                           "changing group %u for file %s\n",
7780                           (unsigned int)set_owner,
7781                           smb_fname_str_dbg(smb_fname)));
7782                 if (fsp && fsp->fh->fd != -1) {
7783                         ret = SMB_VFS_FCHOWN(fsp, set_owner, (gid_t)-1);
7784                 } else {
7785                         /*
7786                          * UNIX extensions calls must always operate
7787                          * on symlinks.
7788                          */
7789                         ret = SMB_VFS_LCHOWN(conn, smb_fname, (uid_t)-1,
7790                                   set_grp);
7791                 }
7792                 if (ret != 0) {
7793                         status = map_nt_error_from_unix(errno);
7794                         if (delete_on_fail) {
7795                                 SMB_VFS_UNLINK(conn, smb_fname);
7796                         }
7797                         return status;
7798                 }
7799         }
7800
7801         /* Deal with any size changes. */
7802
7803         status = smb_set_file_size(conn, req,
7804                                    fsp,
7805                                    smb_fname,
7806                                    &sbuf,
7807                                    size,
7808                                    false);
7809         if (!NT_STATUS_IS_OK(status)) {
7810                 return status;
7811         }
7812
7813         /* Deal with any time changes. */
7814         if (null_timespec(ft.mtime) && null_timespec(ft.atime)) {
7815                 /* No change, don't cancel anything. */
7816                 return status;
7817         }
7818
7819         id = vfs_file_id_from_sbuf(conn, &sbuf);
7820         for(all_fsps = file_find_di_first(conn->sconn, id); all_fsps;
7821                         all_fsps = file_find_di_next(all_fsps)) {
7822                 /*
7823                  * We're setting the time explicitly for UNIX.
7824                  * Cancel any pending changes over all handles.
7825                  */
7826                 all_fsps->update_write_time_on_close = false;
7827                 TALLOC_FREE(all_fsps->update_write_time_event);
7828         }
7829
7830         /*
7831          * Override the "setting_write_time"
7832          * parameter here as it almost does what
7833          * we need. Just remember if we modified
7834          * mtime and send the notify ourselves.
7835          */
7836         if (null_timespec(ft.mtime)) {
7837                 modify_mtime = false;
7838         }
7839
7840         status = smb_set_file_time(conn,
7841                                 fsp,
7842                                 smb_fname,
7843                                 &ft,
7844                                 false);
7845         if (modify_mtime) {
7846                 notify_fname(conn, NOTIFY_ACTION_MODIFIED,
7847                         FILE_NOTIFY_CHANGE_LAST_WRITE, smb_fname->base_name);
7848         }
7849         return status;
7850 }
7851
7852 /****************************************************************************
7853  Deal with SMB_SET_FILE_UNIX_INFO2.
7854 ****************************************************************************/
7855
7856 static NTSTATUS smb_set_file_unix_info2(connection_struct *conn,
7857                                         struct smb_request *req,
7858                                         const char *pdata,
7859                                         int total_data,
7860                                         files_struct *fsp,
7861                                         const struct smb_filename *smb_fname)
7862 {
7863         NTSTATUS status;
7864         uint32_t smb_fflags;
7865         uint32_t smb_fmask;
7866
7867         if (total_data < 116) {
7868                 return NT_STATUS_INVALID_PARAMETER;
7869         }
7870
7871         /* Start by setting all the fields that are common between UNIX_BASIC
7872          * and UNIX_INFO2.
7873          */
7874         status = smb_set_file_unix_basic(conn, req, pdata, total_data,
7875                                          fsp, smb_fname);
7876         if (!NT_STATUS_IS_OK(status)) {
7877                 return status;
7878         }
7879
7880         smb_fflags = IVAL(pdata, 108);
7881         smb_fmask = IVAL(pdata, 112);
7882
7883         /* NB: We should only attempt to alter the file flags if the client
7884          * sends a non-zero mask.
7885          */
7886         if (smb_fmask != 0) {
7887                 int stat_fflags = 0;
7888
7889                 if (!map_info2_flags_to_sbuf(&smb_fname->st, smb_fflags,
7890                                              smb_fmask, &stat_fflags)) {
7891                         /* Client asked to alter a flag we don't understand. */
7892                         return NT_STATUS_INVALID_PARAMETER;
7893                 }
7894
7895                 if (fsp && fsp->fh->fd != -1) {
7896                         /* XXX: we should be  using SMB_VFS_FCHFLAGS here. */
7897                         return NT_STATUS_NOT_SUPPORTED;
7898                 } else {
7899                         if (SMB_VFS_CHFLAGS(conn, smb_fname,
7900                                             stat_fflags) != 0) {
7901                                 return map_nt_error_from_unix(errno);
7902                         }
7903                 }
7904         }
7905
7906         /* XXX: need to add support for changing the create_time here. You
7907          * can do this for paths on Darwin with setattrlist(2). The right way
7908          * to hook this up is probably by extending the VFS utimes interface.
7909          */
7910
7911         return NT_STATUS_OK;
7912 }
7913
7914 /****************************************************************************
7915  Create a directory with POSIX semantics.
7916 ****************************************************************************/
7917
7918 static NTSTATUS smb_posix_mkdir(connection_struct *conn,
7919                                 struct smb_request *req,
7920                                 char **ppdata,
7921                                 int total_data,
7922                                 struct smb_filename *smb_fname,
7923                                 int *pdata_return_size)
7924 {
7925         NTSTATUS status = NT_STATUS_OK;
7926         uint32_t raw_unixmode = 0;
7927         uint32_t mod_unixmode = 0;
7928         mode_t unixmode = (mode_t)0;
7929         files_struct *fsp = NULL;
7930         uint16_t info_level_return = 0;
7931         int info;
7932         char *pdata = *ppdata;
7933
7934         if (total_data < 18) {
7935                 return NT_STATUS_INVALID_PARAMETER;
7936         }
7937
7938         raw_unixmode = IVAL(pdata,8);
7939         /* Next 4 bytes are not yet defined. */
7940
7941         status = unix_perms_from_wire(conn, &smb_fname->st, raw_unixmode,
7942                                       PERM_NEW_DIR, &unixmode);
7943         if (!NT_STATUS_IS_OK(status)) {
7944                 return status;
7945         }
7946
7947         mod_unixmode = (uint32_t)unixmode | FILE_FLAG_POSIX_SEMANTICS;
7948
7949         DEBUG(10,("smb_posix_mkdir: file %s, mode 0%o\n",
7950                   smb_fname_str_dbg(smb_fname), (unsigned int)unixmode));
7951
7952         status = SMB_VFS_CREATE_FILE(
7953                 conn,                                   /* conn */
7954                 req,                                    /* req */
7955                 0,                                      /* root_dir_fid */
7956                 smb_fname,                              /* fname */
7957                 FILE_READ_ATTRIBUTES,                   /* access_mask */
7958                 FILE_SHARE_NONE,                        /* share_access */
7959                 FILE_CREATE,                            /* create_disposition*/
7960                 FILE_DIRECTORY_FILE,                    /* create_options */
7961                 mod_unixmode,                           /* file_attributes */
7962                 0,                                      /* oplock_request */
7963                 NULL,                                   /* lease */
7964                 0,                                      /* allocation_size */
7965                 0,                                      /* private_flags */
7966                 NULL,                                   /* sd */
7967                 NULL,                                   /* ea_list */
7968                 &fsp,                                   /* result */
7969                 &info,                                  /* pinfo */
7970                 NULL, NULL);                            /* create context */
7971
7972         if (NT_STATUS_IS_OK(status)) {
7973                 close_file(req, fsp, NORMAL_CLOSE);
7974         }
7975
7976         info_level_return = SVAL(pdata,16);
7977
7978         if (info_level_return == SMB_QUERY_FILE_UNIX_BASIC) {
7979                 *pdata_return_size = 12 + SMB_FILE_UNIX_BASIC_SIZE;
7980         } else if (info_level_return ==  SMB_QUERY_FILE_UNIX_INFO2) {
7981                 *pdata_return_size = 12 + SMB_FILE_UNIX_INFO2_SIZE;
7982         } else {
7983                 *pdata_return_size = 12;
7984         }
7985
7986         /* Realloc the data size */
7987         *ppdata = (char *)SMB_REALLOC(*ppdata,*pdata_return_size);
7988         if (*ppdata == NULL) {
7989                 *pdata_return_size = 0;
7990                 return NT_STATUS_NO_MEMORY;
7991         }
7992         pdata = *ppdata;
7993
7994         SSVAL(pdata,0,NO_OPLOCK_RETURN);
7995         SSVAL(pdata,2,0); /* No fnum. */
7996         SIVAL(pdata,4,info); /* Was directory created. */
7997
7998         switch (info_level_return) {
7999                 case SMB_QUERY_FILE_UNIX_BASIC:
8000                         SSVAL(pdata,8,SMB_QUERY_FILE_UNIX_BASIC);
8001                         SSVAL(pdata,10,0); /* Padding. */
8002                         store_file_unix_basic(conn, pdata + 12, fsp,
8003                                               &smb_fname->st);
8004                         break;
8005                 case SMB_QUERY_FILE_UNIX_INFO2:
8006                         SSVAL(pdata,8,SMB_QUERY_FILE_UNIX_INFO2);
8007                         SSVAL(pdata,10,0); /* Padding. */
8008                         store_file_unix_basic_info2(conn, pdata + 12, fsp,
8009                                                     &smb_fname->st);
8010                         break;
8011                 default:
8012                         SSVAL(pdata,8,SMB_NO_INFO_LEVEL_RETURNED);
8013                         SSVAL(pdata,10,0); /* Padding. */
8014                         break;
8015         }
8016
8017         return status;
8018 }
8019
8020 /****************************************************************************
8021  Open/Create a file with POSIX semantics.
8022 ****************************************************************************/
8023
8024 #define SMB_O_RDONLY_MAPPING (FILE_READ_DATA|FILE_READ_ATTRIBUTES|FILE_READ_EA)
8025 #define SMB_O_WRONLY_MAPPING (FILE_WRITE_DATA|FILE_WRITE_ATTRIBUTES|FILE_WRITE_EA)
8026
8027 static NTSTATUS smb_posix_open(connection_struct *conn,
8028                                struct smb_request *req,
8029                                 char **ppdata,
8030                                 int total_data,
8031                                 struct smb_filename *smb_fname,
8032                                 int *pdata_return_size)
8033 {
8034         bool extended_oplock_granted = False;
8035         char *pdata = *ppdata;
8036         uint32_t flags = 0;
8037         uint32_t wire_open_mode = 0;
8038         uint32_t raw_unixmode = 0;
8039         uint32_t mod_unixmode = 0;
8040         uint32_t create_disp = 0;
8041         uint32_t access_mask = 0;
8042         uint32_t create_options = FILE_NON_DIRECTORY_FILE;
8043         NTSTATUS status = NT_STATUS_OK;
8044         mode_t unixmode = (mode_t)0;
8045         files_struct *fsp = NULL;
8046         int oplock_request = 0;
8047         int info = 0;
8048         uint16_t info_level_return = 0;
8049
8050         if (total_data < 18) {
8051                 return NT_STATUS_INVALID_PARAMETER;
8052         }
8053
8054         flags = IVAL(pdata,0);
8055         oplock_request = (flags & REQUEST_OPLOCK) ? EXCLUSIVE_OPLOCK : 0;
8056         if (oplock_request) {
8057                 oplock_request |= (flags & REQUEST_BATCH_OPLOCK) ? BATCH_OPLOCK : 0;
8058         }
8059
8060         wire_open_mode = IVAL(pdata,4);
8061
8062         if (wire_open_mode == (SMB_O_CREAT|SMB_O_DIRECTORY)) {
8063                 return smb_posix_mkdir(conn, req,
8064                                         ppdata,
8065                                         total_data,
8066                                         smb_fname,
8067                                         pdata_return_size);
8068         }
8069
8070         switch (wire_open_mode & SMB_ACCMODE) {
8071                 case SMB_O_RDONLY:
8072                         access_mask = SMB_O_RDONLY_MAPPING;
8073                         break;
8074                 case SMB_O_WRONLY:
8075                         access_mask = SMB_O_WRONLY_MAPPING;
8076                         break;
8077                 case SMB_O_RDWR:
8078                         access_mask = (SMB_O_RDONLY_MAPPING|
8079                                         SMB_O_WRONLY_MAPPING);
8080                         break;
8081                 default:
8082                         DEBUG(5,("smb_posix_open: invalid open mode 0x%x\n",
8083                                 (unsigned int)wire_open_mode ));
8084                         return NT_STATUS_INVALID_PARAMETER;
8085         }
8086
8087         wire_open_mode &= ~SMB_ACCMODE;
8088
8089         /* First take care of O_CREAT|O_EXCL interactions. */
8090         switch (wire_open_mode & (SMB_O_CREAT | SMB_O_EXCL)) {
8091                 case (SMB_O_CREAT | SMB_O_EXCL):
8092                         /* File exists fail. File not exist create. */
8093                         create_disp = FILE_CREATE;
8094                         break;
8095                 case SMB_O_CREAT:
8096                         /* File exists open. File not exist create. */
8097                         create_disp = FILE_OPEN_IF;
8098                         break;
8099                 case SMB_O_EXCL:
8100                         /* O_EXCL on its own without O_CREAT is undefined.
8101                            We deliberately ignore it as some versions of
8102                            Linux CIFSFS can send a bare O_EXCL on the
8103                            wire which other filesystems in the kernel
8104                            ignore. See bug 9519 for details. */
8105
8106                         /* Fallthrough. */
8107
8108                 case 0:
8109                         /* File exists open. File not exist fail. */
8110                         create_disp = FILE_OPEN;
8111                         break;
8112                 default:
8113                         DEBUG(5,("smb_posix_open: invalid create mode 0x%x\n",
8114                                 (unsigned int)wire_open_mode ));
8115                         return NT_STATUS_INVALID_PARAMETER;
8116         }
8117
8118         /* Next factor in the effects of O_TRUNC. */
8119         wire_open_mode &= ~(SMB_O_CREAT | SMB_O_EXCL);
8120
8121         if (wire_open_mode & SMB_O_TRUNC) {
8122                 switch (create_disp) {
8123                         case FILE_CREATE:
8124                                 /* (SMB_O_CREAT | SMB_O_EXCL | O_TRUNC) */
8125                                 /* Leave create_disp alone as
8126                                    (O_CREAT|O_EXCL|O_TRUNC) == (O_CREAT|O_EXCL)
8127                                 */
8128                                 /* File exists fail. File not exist create. */
8129                                 break;
8130                         case FILE_OPEN_IF:
8131                                 /* SMB_O_CREAT | SMB_O_TRUNC */
8132                                 /* File exists overwrite. File not exist create. */
8133                                 create_disp = FILE_OVERWRITE_IF;
8134                                 break;
8135                         case FILE_OPEN:
8136                                 /* SMB_O_TRUNC */
8137                                 /* File exists overwrite. File not exist fail. */
8138                                 create_disp = FILE_OVERWRITE;
8139                                 break;
8140                         default:
8141                                 /* Cannot get here. */
8142                                 smb_panic("smb_posix_open: logic error");
8143                                 return NT_STATUS_INVALID_PARAMETER;
8144                 }
8145         }
8146
8147         raw_unixmode = IVAL(pdata,8);
8148         /* Next 4 bytes are not yet defined. */
8149
8150         status = unix_perms_from_wire(conn, &smb_fname->st, raw_unixmode,
8151                                       (VALID_STAT(smb_fname->st) ?
8152                                           PERM_EXISTING_FILE : PERM_NEW_FILE),
8153                                       &unixmode);
8154
8155         if (!NT_STATUS_IS_OK(status)) {
8156                 return status;
8157         }
8158
8159         mod_unixmode = (uint32_t)unixmode | FILE_FLAG_POSIX_SEMANTICS;
8160
8161         if (wire_open_mode & SMB_O_SYNC) {
8162                 create_options |= FILE_WRITE_THROUGH;
8163         }
8164         if (wire_open_mode & SMB_O_APPEND) {
8165                 access_mask |= FILE_APPEND_DATA;
8166         }
8167         if (wire_open_mode & SMB_O_DIRECT) {
8168                 mod_unixmode |= FILE_FLAG_NO_BUFFERING;
8169         }
8170
8171         if ((wire_open_mode & SMB_O_DIRECTORY) ||
8172                         VALID_STAT_OF_DIR(smb_fname->st)) {
8173                 if (access_mask != SMB_O_RDONLY_MAPPING) {
8174                         return NT_STATUS_FILE_IS_A_DIRECTORY;
8175                 }
8176                 create_options &= ~FILE_NON_DIRECTORY_FILE;
8177                 create_options |= FILE_DIRECTORY_FILE;
8178         }
8179
8180         DEBUG(10,("smb_posix_open: file %s, smb_posix_flags = %u, mode 0%o\n",
8181                 smb_fname_str_dbg(smb_fname),
8182                 (unsigned int)wire_open_mode,
8183                 (unsigned int)unixmode ));
8184
8185         status = SMB_VFS_CREATE_FILE(
8186                 conn,                                   /* conn */
8187                 req,                                    /* req */
8188                 0,                                      /* root_dir_fid */
8189                 smb_fname,                              /* fname */
8190                 access_mask,                            /* access_mask */
8191                 (FILE_SHARE_READ | FILE_SHARE_WRITE |   /* share_access */
8192                     FILE_SHARE_DELETE),
8193                 create_disp,                            /* create_disposition*/
8194                 create_options,                         /* create_options */
8195                 mod_unixmode,                           /* file_attributes */
8196                 oplock_request,                         /* oplock_request */
8197                 NULL,                                   /* lease */
8198                 0,                                      /* allocation_size */
8199                 0,                                      /* private_flags */
8200                 NULL,                                   /* sd */
8201                 NULL,                                   /* ea_list */
8202                 &fsp,                                   /* result */
8203                 &info,                                  /* pinfo */
8204                 NULL, NULL);                            /* create context */
8205
8206         if (!NT_STATUS_IS_OK(status)) {
8207                 return status;
8208         }
8209
8210         if (oplock_request && lp_fake_oplocks(SNUM(conn))) {
8211                 extended_oplock_granted = True;
8212         }
8213
8214         if(oplock_request && EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type)) {
8215                 extended_oplock_granted = True;
8216         }
8217
8218         info_level_return = SVAL(pdata,16);
8219
8220         /* Allocate the correct return size. */
8221
8222         if (info_level_return == SMB_QUERY_FILE_UNIX_BASIC) {
8223                 *pdata_return_size = 12 + SMB_FILE_UNIX_BASIC_SIZE;
8224         } else if (info_level_return ==  SMB_QUERY_FILE_UNIX_INFO2) {
8225                 *pdata_return_size = 12 + SMB_FILE_UNIX_INFO2_SIZE;
8226         } else {
8227                 *pdata_return_size = 12;
8228         }
8229
8230         /* Realloc the data size */
8231         *ppdata = (char *)SMB_REALLOC(*ppdata,*pdata_return_size);
8232         if (*ppdata == NULL) {
8233                 close_file(req, fsp, ERROR_CLOSE);
8234                 *pdata_return_size = 0;
8235                 return NT_STATUS_NO_MEMORY;
8236         }
8237         pdata = *ppdata;
8238
8239         if (extended_oplock_granted) {
8240                 if (flags & REQUEST_BATCH_OPLOCK) {
8241                         SSVAL(pdata,0, BATCH_OPLOCK_RETURN);
8242                 } else {
8243                         SSVAL(pdata,0, EXCLUSIVE_OPLOCK_RETURN);
8244                 }
8245         } else if (fsp->oplock_type == LEVEL_II_OPLOCK) {
8246                 SSVAL(pdata,0, LEVEL_II_OPLOCK_RETURN);
8247         } else {
8248                 SSVAL(pdata,0,NO_OPLOCK_RETURN);
8249         }
8250
8251         SSVAL(pdata,2,fsp->fnum);
8252         SIVAL(pdata,4,info); /* Was file created etc. */
8253
8254         switch (info_level_return) {
8255                 case SMB_QUERY_FILE_UNIX_BASIC:
8256                         SSVAL(pdata,8,SMB_QUERY_FILE_UNIX_BASIC);
8257                         SSVAL(pdata,10,0); /* padding. */
8258                         store_file_unix_basic(conn, pdata + 12, fsp,
8259                                               &smb_fname->st);
8260                         break;
8261                 case SMB_QUERY_FILE_UNIX_INFO2:
8262                         SSVAL(pdata,8,SMB_QUERY_FILE_UNIX_INFO2);
8263                         SSVAL(pdata,10,0); /* padding. */
8264                         store_file_unix_basic_info2(conn, pdata + 12, fsp,
8265                                                     &smb_fname->st);
8266                         break;
8267                 default:
8268                         SSVAL(pdata,8,SMB_NO_INFO_LEVEL_RETURNED);
8269                         SSVAL(pdata,10,0); /* padding. */
8270                         break;
8271         }
8272         return NT_STATUS_OK;
8273 }
8274
8275 /****************************************************************************
8276  Delete a file with POSIX semantics.
8277 ****************************************************************************/
8278
8279 static NTSTATUS smb_posix_unlink(connection_struct *conn,
8280                                  struct smb_request *req,
8281                                 const char *pdata,
8282                                 int total_data,
8283                                 struct smb_filename *smb_fname)
8284 {
8285         NTSTATUS status = NT_STATUS_OK;
8286         files_struct *fsp = NULL;
8287         uint16_t flags = 0;
8288         char del = 1;
8289         int info = 0;
8290         int create_options = 0;
8291         int i;
8292         struct share_mode_lock *lck = NULL;
8293
8294         if (total_data < 2) {
8295                 return NT_STATUS_INVALID_PARAMETER;
8296         }
8297
8298         flags = SVAL(pdata,0);
8299
8300         if (!VALID_STAT(smb_fname->st)) {
8301                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
8302         }
8303
8304         if ((flags == SMB_POSIX_UNLINK_DIRECTORY_TARGET) &&
8305                         !VALID_STAT_OF_DIR(smb_fname->st)) {
8306                 return NT_STATUS_NOT_A_DIRECTORY;
8307         }
8308
8309         DEBUG(10,("smb_posix_unlink: %s %s\n",
8310                 (flags == SMB_POSIX_UNLINK_DIRECTORY_TARGET) ? "directory" : "file",
8311                 smb_fname_str_dbg(smb_fname)));
8312
8313         if (VALID_STAT_OF_DIR(smb_fname->st)) {
8314                 create_options |= FILE_DIRECTORY_FILE;
8315         }
8316
8317         status = SMB_VFS_CREATE_FILE(
8318                 conn,                                   /* conn */
8319                 req,                                    /* req */
8320                 0,                                      /* root_dir_fid */
8321                 smb_fname,                              /* fname */
8322                 DELETE_ACCESS,                          /* access_mask */
8323                 (FILE_SHARE_READ | FILE_SHARE_WRITE |   /* share_access */
8324                     FILE_SHARE_DELETE),
8325                 FILE_OPEN,                              /* create_disposition*/
8326                 create_options,                         /* create_options */
8327                 FILE_FLAG_POSIX_SEMANTICS|0777,         /* file_attributes */
8328                 0,                                      /* oplock_request */
8329                 NULL,                                   /* lease */
8330                 0,                                      /* allocation_size */
8331                 0,                                      /* private_flags */
8332                 NULL,                                   /* sd */
8333                 NULL,                                   /* ea_list */
8334                 &fsp,                                   /* result */
8335                 &info,                                  /* pinfo */
8336                 NULL, NULL);                            /* create context */
8337
8338         if (!NT_STATUS_IS_OK(status)) {
8339                 return status;
8340         }
8341
8342         /*
8343          * Don't lie to client. If we can't really delete due to
8344          * non-POSIX opens return SHARING_VIOLATION.
8345          */
8346
8347         lck = get_existing_share_mode_lock(talloc_tos(), fsp->file_id);
8348         if (lck == NULL) {
8349                 DEBUG(0, ("smb_posix_unlink: Could not get share mode "
8350                           "lock for file %s\n", fsp_str_dbg(fsp)));
8351                 close_file(req, fsp, NORMAL_CLOSE);
8352                 return NT_STATUS_INVALID_PARAMETER;
8353         }
8354
8355         /*
8356          * See if others still have the file open. If this is the case, then
8357          * don't delete. If all opens are POSIX delete we can set the delete
8358          * on close disposition.
8359          */
8360         for (i=0; i<lck->data->num_share_modes; i++) {
8361                 struct share_mode_entry *e = &lck->data->share_modes[i];
8362                 if (is_valid_share_mode_entry(e)) {
8363                         if (e->flags & SHARE_MODE_FLAG_POSIX_OPEN) {
8364                                 continue;
8365                         }
8366                         if (share_mode_stale_pid(lck->data, i)) {
8367                                 continue;
8368                         }
8369                         /* Fail with sharing violation. */
8370                         TALLOC_FREE(lck);
8371                         close_file(req, fsp, NORMAL_CLOSE);
8372                         return NT_STATUS_SHARING_VIOLATION;
8373                 }
8374         }
8375
8376         /*
8377          * Set the delete on close.
8378          */
8379         status = smb_set_file_disposition_info(conn,
8380                                                 &del,
8381                                                 1,
8382                                                 fsp,
8383                                                 smb_fname);
8384
8385         TALLOC_FREE(lck);
8386
8387         if (!NT_STATUS_IS_OK(status)) {
8388                 close_file(req, fsp, NORMAL_CLOSE);
8389                 return status;
8390         }
8391         return close_file(req, fsp, NORMAL_CLOSE);
8392 }
8393
8394 NTSTATUS smbd_do_setfilepathinfo(connection_struct *conn,
8395                                 struct smb_request *req,
8396                                 TALLOC_CTX *mem_ctx,
8397                                 uint16_t info_level,
8398                                 files_struct *fsp,
8399                                 struct smb_filename *smb_fname,
8400                                 char **ppdata, int total_data,
8401                                 int *ret_data_size)
8402 {
8403         char *pdata = *ppdata;
8404         NTSTATUS status = NT_STATUS_OK;
8405         int data_return_size = 0;
8406
8407         *ret_data_size = 0;
8408
8409         if (INFO_LEVEL_IS_UNIX(info_level) && !lp_unix_extensions()) {
8410                 return NT_STATUS_INVALID_LEVEL;
8411         }
8412
8413         if (!CAN_WRITE(conn)) {
8414                 /* Allow POSIX opens. The open path will deny
8415                  * any non-readonly opens. */
8416                 if (info_level != SMB_POSIX_PATH_OPEN) {
8417                         return NT_STATUS_DOS(ERRSRV, ERRaccess);
8418                 }
8419         }
8420
8421         DEBUG(3,("smbd_do_setfilepathinfo: %s (%s) info_level=%d "
8422                  "totdata=%d\n", smb_fname_str_dbg(smb_fname),
8423                  fsp_fnum_dbg(fsp),
8424                  info_level, total_data));
8425
8426         switch (info_level) {
8427
8428                 case SMB_INFO_STANDARD:
8429                 {
8430                         status = smb_set_info_standard(conn,
8431                                         pdata,
8432                                         total_data,
8433                                         fsp,
8434                                         smb_fname);
8435                         break;
8436                 }
8437
8438                 case SMB_INFO_SET_EA:
8439                 {
8440                         status = smb_info_set_ea(conn,
8441                                                 pdata,
8442                                                 total_data,
8443                                                 fsp,
8444                                                 smb_fname);
8445                         break;
8446                 }
8447
8448                 case SMB_SET_FILE_BASIC_INFO:
8449                 case SMB_FILE_BASIC_INFORMATION:
8450                 {
8451                         status = smb_set_file_basic_info(conn,
8452                                                         pdata,
8453                                                         total_data,
8454                                                         fsp,
8455                                                         smb_fname);
8456                         break;
8457                 }
8458
8459                 case SMB_FILE_ALLOCATION_INFORMATION:
8460                 case SMB_SET_FILE_ALLOCATION_INFO:
8461                 {
8462                         status = smb_set_file_allocation_info(conn, req,
8463                                                                 pdata,
8464                                                                 total_data,
8465                                                                 fsp,
8466                                                                 smb_fname);
8467                         break;
8468                 }
8469
8470                 case SMB_FILE_END_OF_FILE_INFORMATION:
8471                 case SMB_SET_FILE_END_OF_FILE_INFO:
8472                 {
8473                         /*
8474                          * XP/Win7 both fail after the createfile with
8475                          * SMB_SET_FILE_END_OF_FILE_INFO but not
8476                          * SMB_FILE_END_OF_FILE_INFORMATION (pass-through).
8477                          * The level is known here, so pass it down
8478                          * appropriately.
8479                          */
8480                         bool should_fail =
8481                             (info_level == SMB_SET_FILE_END_OF_FILE_INFO);
8482
8483                         status = smb_set_file_end_of_file_info(conn, req,
8484                                                                 pdata,
8485                                                                 total_data,
8486                                                                 fsp,
8487                                                                 smb_fname,
8488                                                                 should_fail);
8489                         break;
8490                 }
8491
8492                 case SMB_FILE_DISPOSITION_INFORMATION:
8493                 case SMB_SET_FILE_DISPOSITION_INFO: /* Set delete on close for open file. */
8494                 {
8495 #if 0
8496                         /* JRA - We used to just ignore this on a path ?
8497                          * Shouldn't this be invalid level on a pathname
8498                          * based call ?
8499                          */
8500                         if (tran_call != TRANSACT2_SETFILEINFO) {
8501                                 return ERROR_NT(NT_STATUS_INVALID_LEVEL);
8502                         }
8503 #endif
8504                         status = smb_set_file_disposition_info(conn,
8505                                                 pdata,
8506                                                 total_data,
8507                                                 fsp,
8508                                                 smb_fname);
8509                         break;
8510                 }
8511
8512                 case SMB_FILE_POSITION_INFORMATION:
8513                 {
8514                         status = smb_file_position_information(conn,
8515                                                 pdata,
8516                                                 total_data,
8517                                                 fsp);
8518                         break;
8519                 }
8520
8521                 case SMB_FILE_FULL_EA_INFORMATION:
8522                 {
8523                         status = smb_set_file_full_ea_info(conn,
8524                                                 pdata,
8525                                                 total_data,
8526                                                 fsp);
8527                         break;
8528                 }
8529
8530                 /* From tridge Samba4 :
8531                  * MODE_INFORMATION in setfileinfo (I have no
8532                  * idea what "mode information" on a file is - it takes a value of 0,
8533                  * 2, 4 or 6. What could it be?).
8534                  */
8535
8536                 case SMB_FILE_MODE_INFORMATION:
8537                 {
8538                         status = smb_file_mode_information(conn,
8539                                                 pdata,
8540                                                 total_data);
8541                         break;
8542                 }
8543
8544                 /*
8545                  * CIFS UNIX extensions.
8546                  */
8547
8548                 case SMB_SET_FILE_UNIX_BASIC:
8549                 {
8550                         status = smb_set_file_unix_basic(conn, req,
8551                                                         pdata,
8552                                                         total_data,
8553                                                         fsp,
8554                                                         smb_fname);
8555                         break;
8556                 }
8557
8558                 case SMB_SET_FILE_UNIX_INFO2:
8559                 {
8560                         status = smb_set_file_unix_info2(conn, req,
8561                                                         pdata,
8562                                                         total_data,
8563                                                         fsp,
8564                                                         smb_fname);
8565                         break;
8566                 }
8567
8568                 case SMB_SET_FILE_UNIX_LINK:
8569                 {
8570                         if (fsp) {
8571                                 /* We must have a pathname for this. */
8572                                 return NT_STATUS_INVALID_LEVEL;
8573                         }
8574                         status = smb_set_file_unix_link(conn, req, pdata,
8575                                                         total_data, smb_fname);
8576                         break;
8577                 }
8578
8579                 case SMB_SET_FILE_UNIX_HLINK:
8580                 {
8581                         if (fsp) {
8582                                 /* We must have a pathname for this. */
8583                                 return NT_STATUS_INVALID_LEVEL;
8584                         }
8585                         status = smb_set_file_unix_hlink(conn, req,
8586                                                          pdata, total_data,
8587                                                          smb_fname);
8588                         break;
8589                 }
8590
8591                 case SMB_FILE_RENAME_INFORMATION:
8592                 {
8593                         status = smb_file_rename_information(conn, req,
8594                                                              pdata, total_data,
8595                                                              fsp, smb_fname);
8596                         break;
8597                 }
8598
8599                 case SMB2_FILE_RENAME_INFORMATION_INTERNAL:
8600                 {
8601                         /* SMB2 rename information. */
8602                         status = smb2_file_rename_information(conn, req,
8603                                                              pdata, total_data,
8604                                                              fsp, smb_fname);
8605                         break;
8606                 }
8607
8608                 case SMB_FILE_LINK_INFORMATION:
8609                 {
8610                         status = smb_file_link_information(conn, req,
8611                                                         pdata, total_data,
8612                                                         fsp, smb_fname);
8613                         break;
8614                 }
8615
8616 #if defined(HAVE_POSIX_ACLS)
8617                 case SMB_SET_POSIX_ACL:
8618                 {
8619                         status = smb_set_posix_acl(conn,
8620                                                 pdata,
8621                                                 total_data,
8622                                                 fsp,
8623                                                 smb_fname);
8624                         break;
8625                 }
8626 #endif
8627
8628                 case SMB_SET_POSIX_LOCK:
8629                 {
8630                         if (!fsp) {
8631                                 return NT_STATUS_INVALID_LEVEL;
8632                         }
8633                         status = smb_set_posix_lock(conn, req,
8634                                                     pdata, total_data, fsp);
8635                         break;
8636                 }
8637
8638                 case SMB_POSIX_PATH_OPEN:
8639                 {
8640                         if (fsp) {
8641                                 /* We must have a pathname for this. */
8642                                 return NT_STATUS_INVALID_LEVEL;
8643                         }
8644
8645                         status = smb_posix_open(conn, req,
8646                                                 ppdata,
8647                                                 total_data,
8648                                                 smb_fname,
8649                                                 &data_return_size);
8650                         break;
8651                 }
8652
8653                 case SMB_POSIX_PATH_UNLINK:
8654                 {
8655                         if (fsp) {
8656                                 /* We must have a pathname for this. */
8657                                 return NT_STATUS_INVALID_LEVEL;
8658                         }
8659
8660                         status = smb_posix_unlink(conn, req,
8661                                                 pdata,
8662                                                 total_data,
8663                                                 smb_fname);
8664                         break;
8665                 }
8666
8667                 default:
8668                         return NT_STATUS_INVALID_LEVEL;
8669         }
8670
8671         if (!NT_STATUS_IS_OK(status)) {
8672                 return status;
8673         }
8674
8675         *ret_data_size = data_return_size;
8676         return NT_STATUS_OK;
8677 }
8678
8679 /****************************************************************************
8680  Reply to a TRANS2_SETFILEINFO (set file info by fileid or pathname).
8681 ****************************************************************************/
8682
8683 static void call_trans2setfilepathinfo(connection_struct *conn,
8684                                        struct smb_request *req,
8685                                        unsigned int tran_call,
8686                                        char **pparams, int total_params,
8687                                        char **ppdata, int total_data,
8688                                        unsigned int max_data_bytes)
8689 {
8690         char *params = *pparams;
8691         char *pdata = *ppdata;
8692         uint16_t info_level;
8693         struct smb_filename *smb_fname = NULL;
8694         files_struct *fsp = NULL;
8695         NTSTATUS status = NT_STATUS_OK;
8696         int data_return_size = 0;
8697
8698         if (!params) {
8699                 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
8700                 return;
8701         }
8702
8703         if (tran_call == TRANSACT2_SETFILEINFO) {
8704                 if (total_params < 4) {
8705                         reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
8706                         return;
8707                 }
8708
8709                 fsp = file_fsp(req, SVAL(params,0));
8710                 /* Basic check for non-null fsp. */
8711                 if (!check_fsp_open(conn, req, fsp)) {
8712                         return;
8713                 }
8714                 info_level = SVAL(params,2);
8715
8716                 smb_fname = cp_smb_filename(talloc_tos(), fsp->fsp_name);
8717                 if (smb_fname == NULL) {
8718                         reply_nterror(req, NT_STATUS_NO_MEMORY);
8719                         return;
8720                 }
8721
8722                 if(fsp->fh->fd == -1) {
8723                         /*
8724                          * This is actually a SETFILEINFO on a directory
8725                          * handle (returned from an NT SMB). NT5.0 seems
8726                          * to do this call. JRA.
8727                          */
8728                         if (INFO_LEVEL_IS_UNIX(info_level)) {
8729                                 /* Always do lstat for UNIX calls. */
8730                                 if (SMB_VFS_LSTAT(conn, smb_fname)) {
8731                                         DEBUG(3,("call_trans2setfilepathinfo: "
8732                                                  "SMB_VFS_LSTAT of %s failed "
8733                                                  "(%s)\n",
8734                                                  smb_fname_str_dbg(smb_fname),
8735                                                  strerror(errno)));
8736                                         reply_nterror(req, map_nt_error_from_unix(errno));
8737                                         return;
8738                                 }
8739                         } else {
8740                                 if (SMB_VFS_STAT(conn, smb_fname) != 0) {
8741                                         DEBUG(3,("call_trans2setfilepathinfo: "
8742                                                  "fileinfo of %s failed (%s)\n",
8743                                                  smb_fname_str_dbg(smb_fname),
8744                                                  strerror(errno)));
8745                                         reply_nterror(req, map_nt_error_from_unix(errno));
8746                                         return;
8747                                 }
8748                         }
8749                 } else if (fsp->print_file) {
8750                         /*
8751                          * Doing a DELETE_ON_CLOSE should cancel a print job.
8752                          */
8753                         if ((info_level == SMB_SET_FILE_DISPOSITION_INFO) && CVAL(pdata,0)) {
8754                                 fsp->fh->private_options |= NTCREATEX_OPTIONS_PRIVATE_DELETE_ON_CLOSE;
8755
8756                                 DEBUG(3,("call_trans2setfilepathinfo: "
8757                                          "Cancelling print job (%s)\n",
8758                                          fsp_str_dbg(fsp)));
8759
8760                                 SSVAL(params,0,0);
8761                                 send_trans2_replies(conn, req, NT_STATUS_OK, params, 2,
8762                                                     *ppdata, 0,
8763                                                     max_data_bytes);
8764                                 return;
8765                         } else {
8766                                 reply_nterror(req,
8767                                         NT_STATUS_OBJECT_PATH_NOT_FOUND);
8768                                 return;
8769                         }
8770                 } else {
8771                         /*
8772                          * Original code - this is an open file.
8773                          */
8774                         if (SMB_VFS_FSTAT(fsp, &smb_fname->st) != 0) {
8775                                 DEBUG(3,("call_trans2setfilepathinfo: fstat "
8776                                          "of %s failed (%s)\n", fsp_fnum_dbg(fsp),
8777                                          strerror(errno)));
8778                                 reply_nterror(req, map_nt_error_from_unix(errno));
8779                                 return;
8780                         }
8781                 }
8782         } else {
8783                 char *fname = NULL;
8784                 uint32_t ucf_flags = ucf_flags_from_smb_request(req);
8785
8786                 /* set path info */
8787                 if (total_params < 7) {
8788                         reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
8789                         return;
8790                 }
8791
8792                 info_level = SVAL(params,0);
8793                 if (req->posix_pathnames) {
8794                         srvstr_get_path_posix(req,
8795                                 params,
8796                                 req->flags2,
8797                                 &fname,
8798                                 &params[6],
8799                                 total_params - 6,
8800                                 STR_TERMINATE,
8801                                 &status);
8802                 } else {
8803                         srvstr_get_path(req,
8804                                 params,
8805                                 req->flags2,
8806                                 &fname,
8807                                 &params[6],
8808                                 total_params - 6,
8809                                 STR_TERMINATE,
8810                                 &status);
8811                 }
8812                 if (!NT_STATUS_IS_OK(status)) {
8813                         reply_nterror(req, status);
8814                         return;
8815                 }
8816
8817                 if (info_level == SMB_SET_FILE_UNIX_BASIC ||
8818                                 info_level == SMB_SET_FILE_UNIX_INFO2 ||
8819                                 info_level == SMB_FILE_RENAME_INFORMATION ||
8820                                 info_level == SMB_POSIX_PATH_UNLINK) {
8821                         ucf_flags |= UCF_UNIX_NAME_LOOKUP;
8822                 }
8823
8824                 status = filename_convert(req, conn,
8825                                          fname,
8826                                          ucf_flags,
8827                                          NULL,
8828                                          &smb_fname);
8829                 if (!NT_STATUS_IS_OK(status)) {
8830                         if (NT_STATUS_EQUAL(status,NT_STATUS_PATH_NOT_COVERED)) {
8831                                 reply_botherror(req,
8832                                                 NT_STATUS_PATH_NOT_COVERED,
8833                                                 ERRSRV, ERRbadpath);
8834                                 return;
8835                         }
8836                         reply_nterror(req, status);
8837                         return;
8838                 }
8839
8840                 if (INFO_LEVEL_IS_UNIX(info_level)) {
8841                         /*
8842                          * For CIFS UNIX extensions the target name may not exist.
8843                          */
8844
8845                         /* Always do lstat for UNIX calls. */
8846                         SMB_VFS_LSTAT(conn, smb_fname);
8847
8848                 } else if (!VALID_STAT(smb_fname->st) &&
8849                            SMB_VFS_STAT(conn, smb_fname)) {
8850                         DEBUG(3,("call_trans2setfilepathinfo: SMB_VFS_STAT of "
8851                                  "%s failed (%s)\n",
8852                                  smb_fname_str_dbg(smb_fname),
8853                                  strerror(errno)));
8854                         reply_nterror(req, map_nt_error_from_unix(errno));
8855                         return;
8856                 }
8857         }
8858
8859         DEBUG(3,("call_trans2setfilepathinfo(%d) %s (%s) info_level=%d "
8860                  "totdata=%d\n", tran_call, smb_fname_str_dbg(smb_fname),
8861                  fsp_fnum_dbg(fsp),
8862                  info_level,total_data));
8863
8864         /* Realloc the parameter size */
8865         *pparams = (char *)SMB_REALLOC(*pparams,2);
8866         if (*pparams == NULL) {
8867                 reply_nterror(req, NT_STATUS_NO_MEMORY);
8868                 return;
8869         }
8870         params = *pparams;
8871
8872         SSVAL(params,0,0);
8873
8874         status = smbd_do_setfilepathinfo(conn, req, req,
8875                                          info_level,
8876                                          fsp,
8877                                          smb_fname,
8878                                          ppdata, total_data,
8879                                          &data_return_size);
8880         if (!NT_STATUS_IS_OK(status)) {
8881                 if (open_was_deferred(req->xconn, req->mid)) {
8882                         /* We have re-scheduled this call. */
8883                         return;
8884                 }
8885                 if (blocking_lock_was_deferred_smb1(req->sconn, req->mid)) {
8886                         /* We have re-scheduled this call. */
8887                         return;
8888                 }
8889                 if (NT_STATUS_EQUAL(status,NT_STATUS_PATH_NOT_COVERED)) {
8890                         reply_botherror(req, NT_STATUS_PATH_NOT_COVERED,
8891                                         ERRSRV, ERRbadpath);
8892                         return;
8893                 }
8894                 if (info_level == SMB_POSIX_PATH_OPEN) {
8895                         reply_openerror(req, status);
8896                         return;
8897                 }
8898
8899                 /*
8900                  * Invalid EA name needs to return 2 param bytes,
8901                  * not a zero-length error packet.
8902                  */
8903                 if (NT_STATUS_EQUAL(status, STATUS_INVALID_EA_NAME)) {
8904                         send_trans2_replies(conn, req, status, params, 2, NULL, 0,
8905                                         max_data_bytes);
8906                 } else {
8907                         reply_nterror(req, status);
8908                 }
8909                 return;
8910         }
8911
8912         send_trans2_replies(conn, req, NT_STATUS_OK, params, 2, *ppdata, data_return_size,
8913                             max_data_bytes);
8914
8915         return;
8916 }
8917
8918 /****************************************************************************
8919  Reply to a TRANS2_MKDIR (make directory with extended attributes).
8920 ****************************************************************************/
8921
8922 static void call_trans2mkdir(connection_struct *conn, struct smb_request *req,
8923                              char **pparams, int total_params,
8924                              char **ppdata, int total_data,
8925                              unsigned int max_data_bytes)
8926 {
8927         struct smb_filename *smb_dname = NULL;
8928         char *params = *pparams;
8929         char *pdata = *ppdata;
8930         char *directory = NULL;
8931         NTSTATUS status = NT_STATUS_OK;
8932         struct ea_list *ea_list = NULL;
8933         uint32_t ucf_flags = ucf_flags_from_smb_request(req);
8934         TALLOC_CTX *ctx = talloc_tos();
8935
8936         if (!CAN_WRITE(conn)) {
8937                 reply_nterror(req, NT_STATUS_ACCESS_DENIED);
8938                 return;
8939         }
8940
8941         if (total_params < 5) {
8942                 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
8943                 return;
8944         }
8945
8946         if (req->posix_pathnames) {
8947                 srvstr_get_path_posix(ctx,
8948                         params,
8949                         req->flags2,
8950                         &directory,
8951                         &params[4],
8952                         total_params - 4,
8953                         STR_TERMINATE,
8954                         &status);
8955         } else {
8956                 srvstr_get_path(ctx,
8957                         params,
8958                         req->flags2,
8959                         &directory,
8960                         &params[4],
8961                         total_params - 4,
8962                         STR_TERMINATE,
8963                         &status);
8964         }
8965         if (!NT_STATUS_IS_OK(status)) {
8966                 reply_nterror(req, status);
8967                 return;
8968         }
8969
8970         DEBUG(3,("call_trans2mkdir : name = %s\n", directory));
8971
8972         status = filename_convert(ctx,
8973                                 conn,
8974                                 directory,
8975                                 ucf_flags,
8976                                 NULL,
8977                                 &smb_dname);
8978
8979         if (!NT_STATUS_IS_OK(status)) {
8980                 if (NT_STATUS_EQUAL(status,NT_STATUS_PATH_NOT_COVERED)) {
8981                         reply_botherror(req,
8982                                 NT_STATUS_PATH_NOT_COVERED,
8983                                 ERRSRV, ERRbadpath);
8984                         return;
8985                 }
8986                 reply_nterror(req, status);
8987                 return;
8988         }
8989
8990         /*
8991          * OS/2 workplace shell seems to send SET_EA requests of "null"
8992          * length (4 bytes containing IVAL 4).
8993          * They seem to have no effect. Bug #3212. JRA.
8994          */
8995
8996         if (total_data && (total_data != 4)) {
8997                 /* Any data in this call is an EA list. */
8998                 if (total_data < 10) {
8999                         reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
9000                         goto out;
9001                 }
9002
9003                 if (IVAL(pdata,0) > total_data) {
9004                         DEBUG(10,("call_trans2mkdir: bad total data size (%u) > %u\n",
9005                                 IVAL(pdata,0), (unsigned int)total_data));
9006                         reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
9007                         goto out;
9008                 }
9009
9010                 ea_list = read_ea_list(talloc_tos(), pdata + 4,
9011                                        total_data - 4);
9012                 if (!ea_list) {
9013                         reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
9014                         goto out;
9015                 }
9016
9017                 if (!lp_ea_support(SNUM(conn))) {
9018                         reply_nterror(req, NT_STATUS_EAS_NOT_SUPPORTED);
9019                         goto out;
9020                 }
9021         }
9022         /* If total_data == 4 Windows doesn't care what values
9023          * are placed in that field, it just ignores them.
9024          * The System i QNTC IBM SMB client puts bad values here,
9025          * so ignore them. */
9026
9027         status = create_directory(conn, req, smb_dname);
9028
9029         if (!NT_STATUS_IS_OK(status)) {
9030                 reply_nterror(req, status);
9031                 goto out;
9032         }
9033
9034         /* Try and set any given EA. */
9035         if (ea_list) {
9036                 status = set_ea(conn, NULL, smb_dname, ea_list);
9037                 if (!NT_STATUS_IS_OK(status)) {
9038                         reply_nterror(req, status);
9039                         goto out;
9040                 }
9041         }
9042
9043         /* Realloc the parameter and data sizes */
9044         *pparams = (char *)SMB_REALLOC(*pparams,2);
9045         if(*pparams == NULL) {
9046                 reply_nterror(req, NT_STATUS_NO_MEMORY);
9047                 goto out;
9048         }
9049         params = *pparams;
9050
9051         SSVAL(params,0,0);
9052
9053         send_trans2_replies(conn, req, NT_STATUS_OK, params, 2, *ppdata, 0, max_data_bytes);
9054
9055  out:
9056         TALLOC_FREE(smb_dname);
9057         return;
9058 }
9059
9060 /****************************************************************************
9061  Reply to a TRANS2_FINDNOTIFYFIRST (start monitoring a directory for changes).
9062  We don't actually do this - we just send a null response.
9063 ****************************************************************************/
9064
9065 static void call_trans2findnotifyfirst(connection_struct *conn,
9066                                        struct smb_request *req,
9067                                        char **pparams, int total_params,
9068                                        char **ppdata, int total_data,
9069                                        unsigned int max_data_bytes)
9070 {
9071         char *params = *pparams;
9072         uint16_t info_level;
9073
9074         if (total_params < 6) {
9075                 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
9076                 return;
9077         }
9078
9079         info_level = SVAL(params,4);
9080         DEBUG(3,("call_trans2findnotifyfirst - info_level %d\n", info_level));
9081
9082         switch (info_level) {
9083                 case 1:
9084                 case 2:
9085                         break;
9086                 default:
9087                         reply_nterror(req, NT_STATUS_INVALID_LEVEL);
9088                         return;
9089         }
9090
9091         /* Realloc the parameter and data sizes */
9092         *pparams = (char *)SMB_REALLOC(*pparams,6);
9093         if (*pparams == NULL) {
9094                 reply_nterror(req, NT_STATUS_NO_MEMORY);
9095                 return;
9096         }
9097         params = *pparams;
9098
9099         SSVAL(params,0,fnf_handle);
9100         SSVAL(params,2,0); /* No changes */
9101         SSVAL(params,4,0); /* No EA errors */
9102
9103         fnf_handle++;
9104
9105         if(fnf_handle == 0)
9106                 fnf_handle = 257;
9107
9108         send_trans2_replies(conn, req, NT_STATUS_OK, params, 6, *ppdata, 0, max_data_bytes);
9109
9110         return;
9111 }
9112
9113 /****************************************************************************
9114  Reply to a TRANS2_FINDNOTIFYNEXT (continue monitoring a directory for
9115  changes). Currently this does nothing.
9116 ****************************************************************************/
9117
9118 static void call_trans2findnotifynext(connection_struct *conn,
9119                                       struct smb_request *req,
9120                                       char **pparams, int total_params,
9121                                       char **ppdata, int total_data,
9122                                       unsigned int max_data_bytes)
9123 {
9124         char *params = *pparams;
9125
9126         DEBUG(3,("call_trans2findnotifynext\n"));
9127
9128         /* Realloc the parameter and data sizes */
9129         *pparams = (char *)SMB_REALLOC(*pparams,4);
9130         if (*pparams == NULL) {
9131                 reply_nterror(req, NT_STATUS_NO_MEMORY);
9132                 return;
9133         }
9134         params = *pparams;
9135
9136         SSVAL(params,0,0); /* No changes */
9137         SSVAL(params,2,0); /* No EA errors */
9138
9139         send_trans2_replies(conn, req, NT_STATUS_OK, params, 4, *ppdata, 0, max_data_bytes);
9140
9141         return;
9142 }
9143
9144 /****************************************************************************
9145  Reply to a TRANS2_GET_DFS_REFERRAL - Shirish Kalele <kalele@veritas.com>.
9146 ****************************************************************************/
9147
9148 static void call_trans2getdfsreferral(connection_struct *conn,
9149                                       struct smb_request *req,
9150                                       char **pparams, int total_params,
9151                                       char **ppdata, int total_data,
9152                                       unsigned int max_data_bytes)
9153 {
9154         char *params = *pparams;
9155         char *pathname = NULL;
9156         int reply_size = 0;
9157         int max_referral_level;
9158         NTSTATUS status = NT_STATUS_OK;
9159         TALLOC_CTX *ctx = talloc_tos();
9160
9161         DEBUG(10,("call_trans2getdfsreferral\n"));
9162
9163         if (total_params < 3) {
9164                 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
9165                 return;
9166         }
9167
9168         max_referral_level = SVAL(params,0);
9169
9170         if(!lp_host_msdfs()) {
9171                 reply_nterror(req, NT_STATUS_NOT_IMPLEMENTED);
9172                 return;
9173         }
9174
9175         srvstr_pull_talloc(ctx, params, req->flags2, &pathname, &params[2],
9176                     total_params - 2, STR_TERMINATE);
9177         if (!pathname) {
9178                 reply_nterror(req, NT_STATUS_NOT_FOUND);
9179                 return;
9180         }
9181         if((reply_size = setup_dfs_referral(conn, pathname, max_referral_level,
9182                                             ppdata,&status)) < 0) {
9183                 reply_nterror(req, status);
9184                 return;
9185         }
9186
9187         SSVAL((discard_const_p(uint8_t, req->inbuf)), smb_flg2,
9188               SVAL(req->inbuf,smb_flg2) | FLAGS2_DFS_PATHNAMES);
9189         send_trans2_replies(conn, req, NT_STATUS_OK, 0,0,*ppdata,reply_size, max_data_bytes);
9190
9191         return;
9192 }
9193
9194 #define LMCAT_SPL       0x53
9195 #define LMFUNC_GETJOBID 0x60
9196
9197 /****************************************************************************
9198  Reply to a TRANS2_IOCTL - used for OS/2 printing.
9199 ****************************************************************************/
9200
9201 static void call_trans2ioctl(connection_struct *conn,
9202                              struct smb_request *req,
9203                              char **pparams, int total_params,
9204                              char **ppdata, int total_data,
9205                              unsigned int max_data_bytes)
9206 {
9207         char *pdata = *ppdata;
9208         files_struct *fsp = file_fsp(req, SVAL(req->vwv+15, 0));
9209         NTSTATUS status;
9210         size_t len = 0;
9211
9212         /* check for an invalid fid before proceeding */
9213
9214         if (!fsp) {
9215                 reply_nterror(req, NT_STATUS_INVALID_HANDLE);
9216                 return;
9217         }
9218
9219         if ((SVAL(req->vwv+16, 0) == LMCAT_SPL)
9220             && (SVAL(req->vwv+17, 0) == LMFUNC_GETJOBID)) {
9221                 *ppdata = (char *)SMB_REALLOC(*ppdata, 32);
9222                 if (*ppdata == NULL) {
9223                         reply_nterror(req, NT_STATUS_NO_MEMORY);
9224                         return;
9225                 }
9226                 pdata = *ppdata;
9227
9228                 /* NOTE - THIS IS ASCII ONLY AT THE MOMENT - NOT SURE IF OS/2
9229                         CAN ACCEPT THIS IN UNICODE. JRA. */
9230
9231                 /* Job number */
9232                 SSVAL(pdata, 0, print_spool_rap_jobid(fsp->print_file));
9233
9234                 status = srvstr_push(pdata, req->flags2, pdata + 2,
9235                             lp_netbios_name(), 15,
9236                             STR_ASCII|STR_TERMINATE, &len); /* Our NetBIOS name */
9237                 if (!NT_STATUS_IS_OK(status)) {
9238                         reply_nterror(req, status);
9239                         return;
9240                 }
9241                 status = srvstr_push(pdata, req->flags2, pdata+18,
9242                             lp_servicename(talloc_tos(), SNUM(conn)), 13,
9243                             STR_ASCII|STR_TERMINATE, &len); /* Service name */
9244                 if (!NT_STATUS_IS_OK(status)) {
9245                         reply_nterror(req, status);
9246                         return;
9247                 }
9248                 send_trans2_replies(conn, req, NT_STATUS_OK, *pparams, 0, *ppdata, 32,
9249                                     max_data_bytes);
9250                 return;
9251         }
9252
9253         DEBUG(2,("Unknown TRANS2_IOCTL\n"));
9254         reply_nterror(req, NT_STATUS_NOT_IMPLEMENTED);
9255 }
9256
9257 /****************************************************************************
9258  Reply to a SMBfindclose (stop trans2 directory search).
9259 ****************************************************************************/
9260
9261 void reply_findclose(struct smb_request *req)
9262 {
9263         int dptr_num;
9264         struct smbd_server_connection *sconn = req->sconn;
9265
9266         START_PROFILE(SMBfindclose);
9267
9268         if (req->wct < 1) {
9269                 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
9270                 END_PROFILE(SMBfindclose);
9271                 return;
9272         }
9273
9274         dptr_num = SVALS(req->vwv+0, 0);
9275
9276         DEBUG(3,("reply_findclose, dptr_num = %d\n", dptr_num));
9277
9278         dptr_close(sconn, &dptr_num);
9279
9280         reply_outbuf(req, 0, 0);
9281
9282         DEBUG(3,("SMBfindclose dptr_num = %d\n", dptr_num));
9283
9284         END_PROFILE(SMBfindclose);
9285         return;
9286 }
9287
9288 /****************************************************************************
9289  Reply to a SMBfindnclose (stop FINDNOTIFYFIRST directory search).
9290 ****************************************************************************/
9291
9292 void reply_findnclose(struct smb_request *req)
9293 {
9294         int dptr_num;
9295
9296         START_PROFILE(SMBfindnclose);
9297
9298         if (req->wct < 1) {
9299                 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
9300                 END_PROFILE(SMBfindnclose);
9301                 return;
9302         }
9303
9304         dptr_num = SVAL(req->vwv+0, 0);
9305
9306         DEBUG(3,("reply_findnclose, dptr_num = %d\n", dptr_num));
9307
9308         /* We never give out valid handles for a
9309            findnotifyfirst - so any dptr_num is ok here.
9310            Just ignore it. */
9311
9312         reply_outbuf(req, 0, 0);
9313
9314         DEBUG(3,("SMB_findnclose dptr_num = %d\n", dptr_num));
9315
9316         END_PROFILE(SMBfindnclose);
9317         return;
9318 }
9319
9320 static void handle_trans2(connection_struct *conn, struct smb_request *req,
9321                           struct trans_state *state)
9322 {
9323         if (get_Protocol() >= PROTOCOL_NT1) {
9324                 req->flags2 |= 0x40; /* IS_LONG_NAME */
9325                 SSVAL((discard_const_p(uint8_t, req->inbuf)),smb_flg2,req->flags2);
9326         }
9327
9328         if (ENCRYPTION_REQUIRED(conn) && !req->encrypted) {
9329                 if (state->call != TRANSACT2_QFSINFO &&
9330                     state->call != TRANSACT2_SETFSINFO) {
9331                         DEBUG(0,("handle_trans2: encryption required "
9332                                 "with call 0x%x\n",
9333                                 (unsigned int)state->call));
9334                         reply_nterror(req, NT_STATUS_ACCESS_DENIED);
9335                         return;
9336                 }
9337         }
9338
9339         SMB_PERFCOUNT_SET_SUBOP(&req->pcd, state->call);
9340
9341         /* Now we must call the relevant TRANS2 function */
9342         switch(state->call)  {
9343         case TRANSACT2_OPEN:
9344         {
9345                 START_PROFILE(Trans2_open);
9346                 call_trans2open(conn, req,
9347                                 &state->param, state->total_param,
9348                                 &state->data, state->total_data,
9349                                 state->max_data_return);
9350                 END_PROFILE(Trans2_open);
9351                 break;
9352         }
9353
9354         case TRANSACT2_FINDFIRST:
9355         {
9356                 START_PROFILE(Trans2_findfirst);
9357                 call_trans2findfirst(conn, req,
9358                                      &state->param, state->total_param,
9359                                      &state->data, state->total_data,
9360                                      state->max_data_return);
9361                 END_PROFILE(Trans2_findfirst);
9362                 break;
9363         }
9364
9365         case TRANSACT2_FINDNEXT:
9366         {
9367                 START_PROFILE(Trans2_findnext);
9368                 call_trans2findnext(conn, req,
9369                                     &state->param, state->total_param,
9370                                     &state->data, state->total_data,
9371                                     state->max_data_return);
9372                 END_PROFILE(Trans2_findnext);
9373                 break;
9374         }
9375
9376         case TRANSACT2_QFSINFO:
9377         {
9378                 START_PROFILE(Trans2_qfsinfo);
9379                 call_trans2qfsinfo(conn, req,
9380                                    &state->param, state->total_param,
9381                                    &state->data, state->total_data,
9382                                    state->max_data_return);
9383                 END_PROFILE(Trans2_qfsinfo);
9384             break;
9385         }
9386
9387         case TRANSACT2_SETFSINFO:
9388         {
9389                 START_PROFILE(Trans2_setfsinfo);
9390                 call_trans2setfsinfo(conn, req,
9391                                      &state->param, state->total_param,
9392                                      &state->data, state->total_data,
9393                                      state->max_data_return);
9394                 END_PROFILE(Trans2_setfsinfo);
9395                 break;
9396         }
9397
9398         case TRANSACT2_QPATHINFO:
9399         case TRANSACT2_QFILEINFO:
9400         {
9401                 START_PROFILE(Trans2_qpathinfo);
9402                 call_trans2qfilepathinfo(conn, req, state->call,
9403                                          &state->param, state->total_param,
9404                                          &state->data, state->total_data,
9405                                          state->max_data_return);
9406                 END_PROFILE(Trans2_qpathinfo);
9407                 break;
9408         }
9409
9410         case TRANSACT2_SETPATHINFO:
9411         case TRANSACT2_SETFILEINFO:
9412         {
9413                 START_PROFILE(Trans2_setpathinfo);
9414                 call_trans2setfilepathinfo(conn, req, state->call,
9415                                            &state->param, state->total_param,
9416                                            &state->data, state->total_data,
9417                                            state->max_data_return);
9418                 END_PROFILE(Trans2_setpathinfo);
9419                 break;
9420         }
9421
9422         case TRANSACT2_FINDNOTIFYFIRST:
9423         {
9424                 START_PROFILE(Trans2_findnotifyfirst);
9425                 call_trans2findnotifyfirst(conn, req,
9426                                            &state->param, state->total_param,
9427                                            &state->data, state->total_data,
9428                                            state->max_data_return);
9429                 END_PROFILE(Trans2_findnotifyfirst);
9430                 break;
9431         }
9432
9433         case TRANSACT2_FINDNOTIFYNEXT:
9434         {
9435                 START_PROFILE(Trans2_findnotifynext);
9436                 call_trans2findnotifynext(conn, req,
9437                                           &state->param, state->total_param,
9438                                           &state->data, state->total_data,
9439                                           state->max_data_return);
9440                 END_PROFILE(Trans2_findnotifynext);
9441                 break;
9442         }
9443
9444         case TRANSACT2_MKDIR:
9445         {
9446                 START_PROFILE(Trans2_mkdir);
9447                 call_trans2mkdir(conn, req,
9448                                  &state->param, state->total_param,
9449                                  &state->data, state->total_data,
9450                                  state->max_data_return);
9451                 END_PROFILE(Trans2_mkdir);
9452                 break;
9453         }
9454
9455         case TRANSACT2_GET_DFS_REFERRAL:
9456         {
9457                 START_PROFILE(Trans2_get_dfs_referral);
9458                 call_trans2getdfsreferral(conn, req,
9459                                           &state->param, state->total_param,
9460                                           &state->data, state->total_data,
9461                                           state->max_data_return);
9462                 END_PROFILE(Trans2_get_dfs_referral);
9463                 break;
9464         }
9465
9466         case TRANSACT2_IOCTL:
9467         {
9468                 START_PROFILE(Trans2_ioctl);
9469                 call_trans2ioctl(conn, req,
9470                                  &state->param, state->total_param,
9471                                  &state->data, state->total_data,
9472                                  state->max_data_return);
9473                 END_PROFILE(Trans2_ioctl);
9474                 break;
9475         }
9476
9477         default:
9478                 /* Error in request */
9479                 DEBUG(2,("Unknown request %d in trans2 call\n", state->call));
9480                 reply_nterror(req, NT_STATUS_NOT_IMPLEMENTED);
9481         }
9482 }
9483
9484 /****************************************************************************
9485  Reply to a SMBtrans2.
9486  ****************************************************************************/
9487
9488 void reply_trans2(struct smb_request *req)
9489 {
9490         connection_struct *conn = req->conn;
9491         unsigned int dsoff;
9492         unsigned int dscnt;
9493         unsigned int psoff;
9494         unsigned int pscnt;
9495         unsigned int tran_call;
9496         struct trans_state *state;
9497         NTSTATUS result;
9498
9499         START_PROFILE(SMBtrans2);
9500
9501         if (req->wct < 14) {
9502                 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
9503                 END_PROFILE(SMBtrans2);
9504                 return;
9505         }
9506
9507         dsoff = SVAL(req->vwv+12, 0);
9508         dscnt = SVAL(req->vwv+11, 0);
9509         psoff = SVAL(req->vwv+10, 0);
9510         pscnt = SVAL(req->vwv+9, 0);
9511         tran_call = SVAL(req->vwv+14, 0);
9512
9513         result = allow_new_trans(conn->pending_trans, req->mid);
9514         if (!NT_STATUS_IS_OK(result)) {
9515                 DEBUG(2, ("Got invalid trans2 request: %s\n",
9516                           nt_errstr(result)));
9517                 reply_nterror(req, result);
9518                 END_PROFILE(SMBtrans2);
9519                 return;
9520         }
9521
9522         if (IS_IPC(conn)) {
9523                 switch (tran_call) {
9524                 /* List the allowed trans2 calls on IPC$ */
9525                 case TRANSACT2_OPEN:
9526                 case TRANSACT2_GET_DFS_REFERRAL:
9527                 case TRANSACT2_QFILEINFO:
9528                 case TRANSACT2_QFSINFO:
9529                 case TRANSACT2_SETFSINFO:
9530                         break;
9531                 default:
9532                         reply_nterror(req, NT_STATUS_ACCESS_DENIED);
9533                         END_PROFILE(SMBtrans2);
9534                         return;
9535                 }
9536         }
9537
9538         if ((state = talloc(conn, struct trans_state)) == NULL) {
9539                 DEBUG(0, ("talloc failed\n"));
9540                 reply_nterror(req, NT_STATUS_NO_MEMORY);
9541                 END_PROFILE(SMBtrans2);
9542                 return;
9543         }
9544
9545         state->cmd = SMBtrans2;
9546
9547         state->mid = req->mid;
9548         state->vuid = req->vuid;
9549         state->setup_count = SVAL(req->vwv+13, 0);
9550         state->setup = NULL;
9551         state->total_param = SVAL(req->vwv+0, 0);
9552         state->param = NULL;
9553         state->total_data =  SVAL(req->vwv+1, 0);
9554         state->data = NULL;
9555         state->max_param_return = SVAL(req->vwv+2, 0);
9556         state->max_data_return  = SVAL(req->vwv+3, 0);
9557         state->max_setup_return = SVAL(req->vwv+4, 0);
9558         state->close_on_completion = BITSETW(req->vwv+5, 0);
9559         state->one_way = BITSETW(req->vwv+5, 1);
9560
9561         state->call = tran_call;
9562
9563         /* All trans2 messages we handle have smb_sucnt == 1 - ensure this
9564            is so as a sanity check */
9565         if (state->setup_count != 1) {
9566                 /*
9567                  * Need to have rc=0 for ioctl to get job id for OS/2.
9568                  *  Network printing will fail if function is not successful.
9569                  *  Similar function in reply.c will be used if protocol
9570                  *  is LANMAN1.0 instead of LM1.2X002.
9571                  *  Until DosPrintSetJobInfo with PRJINFO3 is supported,
9572                  *  outbuf doesn't have to be set(only job id is used).
9573                  */
9574                 if ( (state->setup_count == 4)
9575                      && (tran_call == TRANSACT2_IOCTL)
9576                      && (SVAL(req->vwv+16, 0) == LMCAT_SPL)
9577                      && (SVAL(req->vwv+17, 0) == LMFUNC_GETJOBID)) {
9578                         DEBUG(2,("Got Trans2 DevIOctl jobid\n"));
9579                 } else {
9580                         DEBUG(2,("Invalid smb_sucnt in trans2 call(%u)\n",state->setup_count));
9581                         DEBUG(2,("Transaction is %d\n",tran_call));
9582                         TALLOC_FREE(state);
9583                         reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
9584                         END_PROFILE(SMBtrans2);
9585                         return;
9586                 }
9587         }
9588
9589         if ((dscnt > state->total_data) || (pscnt > state->total_param))
9590                 goto bad_param;
9591
9592         if (state->total_data) {
9593
9594                 if (trans_oob(state->total_data, 0, dscnt)
9595                     || trans_oob(smb_len(req->inbuf), dsoff, dscnt)) {
9596                         goto bad_param;
9597                 }
9598
9599                 /* Can't use talloc here, the core routines do realloc on the
9600                  * params and data. */
9601                 state->data = (char *)SMB_MALLOC(state->total_data);
9602                 if (state->data == NULL) {
9603                         DEBUG(0,("reply_trans2: data malloc fail for %u "
9604                                  "bytes !\n", (unsigned int)state->total_data));
9605                         TALLOC_FREE(state);
9606                         reply_nterror(req, NT_STATUS_NO_MEMORY);
9607                         END_PROFILE(SMBtrans2);
9608                         return;
9609                 }
9610
9611                 memcpy(state->data,smb_base(req->inbuf)+dsoff,dscnt);
9612         }
9613
9614         if (state->total_param) {
9615
9616                 if (trans_oob(state->total_param, 0, pscnt)
9617                     || trans_oob(smb_len(req->inbuf), psoff, pscnt)) {
9618                         goto bad_param;
9619                 }
9620
9621                 /* Can't use talloc here, the core routines do realloc on the
9622                  * params and data. */
9623                 state->param = (char *)SMB_MALLOC(state->total_param);
9624                 if (state->param == NULL) {
9625                         DEBUG(0,("reply_trans: param malloc fail for %u "
9626                                  "bytes !\n", (unsigned int)state->total_param));
9627                         SAFE_FREE(state->data);
9628                         TALLOC_FREE(state);
9629                         reply_nterror(req, NT_STATUS_NO_MEMORY);
9630                         END_PROFILE(SMBtrans2);
9631                         return;
9632                 }
9633
9634                 memcpy(state->param,smb_base(req->inbuf)+psoff,pscnt);
9635         }
9636
9637         state->received_data  = dscnt;
9638         state->received_param = pscnt;
9639
9640         if ((state->received_param == state->total_param) &&
9641             (state->received_data == state->total_data)) {
9642
9643                 handle_trans2(conn, req, state);
9644
9645                 SAFE_FREE(state->data);
9646                 SAFE_FREE(state->param);
9647                 TALLOC_FREE(state);
9648                 END_PROFILE(SMBtrans2);
9649                 return;
9650         }
9651
9652         DLIST_ADD(conn->pending_trans, state);
9653
9654         /* We need to send an interim response then receive the rest
9655            of the parameter/data bytes */
9656         reply_outbuf(req, 0, 0);
9657         show_msg((char *)req->outbuf);
9658         END_PROFILE(SMBtrans2);
9659         return;
9660
9661   bad_param:
9662
9663         DEBUG(0,("reply_trans2: invalid trans parameters\n"));
9664         SAFE_FREE(state->data);
9665         SAFE_FREE(state->param);
9666         TALLOC_FREE(state);
9667         END_PROFILE(SMBtrans2);
9668         reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
9669 }
9670
9671
9672 /****************************************************************************
9673  Reply to a SMBtranss2
9674  ****************************************************************************/
9675
9676 void reply_transs2(struct smb_request *req)
9677 {
9678         connection_struct *conn = req->conn;
9679         unsigned int pcnt,poff,dcnt,doff,pdisp,ddisp;
9680         struct trans_state *state;
9681
9682         START_PROFILE(SMBtranss2);
9683
9684         show_msg((const char *)req->inbuf);
9685
9686         /* Windows clients expect all replies to
9687            a transact secondary (SMBtranss2 0x33)
9688            to have a command code of transact
9689            (SMBtrans2 0x32). See bug #8989
9690            and also [MS-CIFS] section 2.2.4.47.2
9691            for details.
9692         */
9693         req->cmd = SMBtrans2;
9694
9695         if (req->wct < 8) {
9696                 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
9697                 END_PROFILE(SMBtranss2);
9698                 return;
9699         }
9700
9701         for (state = conn->pending_trans; state != NULL;
9702              state = state->next) {
9703                 if (state->mid == req->mid) {
9704                         break;
9705                 }
9706         }
9707
9708         if ((state == NULL) || (state->cmd != SMBtrans2)) {
9709                 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
9710                 END_PROFILE(SMBtranss2);
9711                 return;
9712         }
9713
9714         /* Revise state->total_param and state->total_data in case they have
9715            changed downwards */
9716
9717         if (SVAL(req->vwv+0, 0) < state->total_param)
9718                 state->total_param = SVAL(req->vwv+0, 0);
9719         if (SVAL(req->vwv+1, 0) < state->total_data)
9720                 state->total_data = SVAL(req->vwv+1, 0);
9721
9722         pcnt = SVAL(req->vwv+2, 0);
9723         poff = SVAL(req->vwv+3, 0);
9724         pdisp = SVAL(req->vwv+4, 0);
9725
9726         dcnt = SVAL(req->vwv+5, 0);
9727         doff = SVAL(req->vwv+6, 0);
9728         ddisp = SVAL(req->vwv+7, 0);
9729
9730         state->received_param += pcnt;
9731         state->received_data += dcnt;
9732
9733         if ((state->received_data > state->total_data) ||
9734             (state->received_param > state->total_param))
9735                 goto bad_param;
9736
9737         if (pcnt) {
9738                 if (trans_oob(state->total_param, pdisp, pcnt)
9739                     || trans_oob(smb_len(req->inbuf), poff, pcnt)) {
9740                         goto bad_param;
9741                 }
9742                 memcpy(state->param+pdisp,smb_base(req->inbuf)+poff,pcnt);
9743         }
9744
9745         if (dcnt) {
9746                 if (trans_oob(state->total_data, ddisp, dcnt)
9747                     || trans_oob(smb_len(req->inbuf), doff, dcnt)) {
9748                         goto bad_param;
9749                 }
9750                 memcpy(state->data+ddisp, smb_base(req->inbuf)+doff,dcnt);
9751         }
9752
9753         if ((state->received_param < state->total_param) ||
9754             (state->received_data < state->total_data)) {
9755                 END_PROFILE(SMBtranss2);
9756                 return;
9757         }
9758
9759         handle_trans2(conn, req, state);
9760
9761         DLIST_REMOVE(conn->pending_trans, state);
9762         SAFE_FREE(state->data);
9763         SAFE_FREE(state->param);
9764         TALLOC_FREE(state);
9765
9766         END_PROFILE(SMBtranss2);
9767         return;
9768
9769   bad_param:
9770
9771         DEBUG(0,("reply_transs2: invalid trans parameters\n"));
9772         DLIST_REMOVE(conn->pending_trans, state);
9773         SAFE_FREE(state->data);
9774         SAFE_FREE(state->param);
9775         TALLOC_FREE(state);
9776         reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
9777         END_PROFILE(SMBtranss2);
9778         return;
9779 }