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