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