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