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