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