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