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