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