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