source/smbd/open.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    file opening and share modes
   4    Copyright (C) Andrew Tridgell 1992-1998
   5    Copyright (C) Jeremy Allison 2001-2004
   6    Copyright (C) Volker Lendecke 2005
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20 */
  21
  22 #include "includes.h"
  23
  24 extern const struct generic_mapping file_generic_mapping;
  25 extern bool global_client_failed_oplock_break;
  26
  27 struct deferred_open_record {
  28         bool delayed_for_oplocks;
  29         struct file_id id;
  30 };
  31
  32 /****************************************************************************
  33  SMB1 file varient of se_access_check. Never test FILE_READ_ATTRIBUTES.
  34 ****************************************************************************/
  35
  36 NTSTATUS smb1_file_se_access_check(const struct security_descriptor *sd,
  37                           const NT_USER_TOKEN *token,
  38                           uint32_t access_desired,
  39                           uint32_t *access_granted)
  40 {
  41         return se_access_check(sd,
  42                                 token,
  43                                 (access_desired & ~FILE_READ_ATTRIBUTES),
  44                                 access_granted);
  45 }
  46
  47 /****************************************************************************
  48  Check if we have open rights.
  49 ****************************************************************************/
  50
  51 static NTSTATUS check_open_rights(struct connection_struct *conn,
  52                                 const char *fname,
  53                                 uint32_t access_mask,
  54                                 uint32_t *access_granted)
  55 {
  56         /* Check if we have rights to open. */
  57         NTSTATUS status;
  58         struct security_descriptor *sd;
  59
  60         *access_granted = 0;
  61
  62         status = SMB_VFS_GET_NT_ACL(conn, fname,
  63                         (OWNER_SECURITY_INFORMATION |
  64                         GROUP_SECURITY_INFORMATION |
  65                         DACL_SECURITY_INFORMATION),&sd);
  66
  67         if (!NT_STATUS_IS_OK(status)) {
  68                 DEBUG(10, ("check_open_rights: Could not get acl "
  69                         "on %s: %s\n",
  70                         fname,
  71                         nt_errstr(status)));
  72                 return status;
  73         }
  74
  75         status = smb1_file_se_access_check(sd,
  76                                 conn->server_info->ptok,
  77                                 access_mask,
  78                                 access_granted);
  79
  80         TALLOC_FREE(sd);
  81
  82         DEBUG(10,("check_open_rights: file %s requesting "
  83                 "0x%x returning 0x%x (%s)\n",
  84                 fname,
  85                 (unsigned int)access_mask,
  86                 (unsigned int)*access_granted,
  87                 nt_errstr(status) ));
  88
  89         return status;
  90 }
  91
  92 /****************************************************************************
  93  fd support routines - attempt to do a dos_open.
  94 ****************************************************************************/
  95
  96 static NTSTATUS fd_open(struct connection_struct *conn,
  97                     const char *fname,
  98                     files_struct *fsp,
  99                     int flags,
 100                     mode_t mode)
 101 {
 102         NTSTATUS status = NT_STATUS_OK;
 103
 104 #ifdef O_NOFOLLOW
 105         /*
 106          * Never follow symlinks on a POSIX client. The
 107          * client should be doing this.
 108          */
 109
 110         if (fsp->posix_open || !lp_symlinks(SNUM(conn))) {
 111                 flags |= O_NOFOLLOW;
 112         }
 113 #endif
 114
 115         fsp->fh->fd = SMB_VFS_OPEN(conn,fname,fsp,flags,mode);
 116         if (fsp->fh->fd == -1) {
 117                 status = map_nt_error_from_unix(errno);
 118         }
 119
 120         DEBUG(10,("fd_open: name %s, flags = 0%o mode = 0%o, fd = %d. %s\n",
 121                     fname, flags, (int)mode, fsp->fh->fd,
 122                 (fsp->fh->fd == -1) ? strerror(errno) : "" ));
 123
 124         return status;
 125 }
 126
 127 /****************************************************************************
 128  Close the file associated with a fsp.
 129 ****************************************************************************/
 130
 131 NTSTATUS fd_close(files_struct *fsp)
 132 {
 133         int ret;
 134
 135         if (fsp->fh->fd == -1) {
 136                 return NT_STATUS_OK; /* What we used to call a stat open. */
 137         }
 138         if (fsp->fh->ref_count > 1) {
 139                 return NT_STATUS_OK; /* Shared handle. Only close last reference. */
 140         }
 141
 142         ret = SMB_VFS_CLOSE(fsp);
 143         fsp->fh->fd = -1;
 144         if (ret == -1) {
 145                 return map_nt_error_from_unix(errno);
 146         }
 147         return NT_STATUS_OK;
 148 }
 149
 150 /****************************************************************************
 151  Change the ownership of a file to that of the parent directory.
 152  Do this by fd if possible.
 153 ****************************************************************************/
 154
 155 static void change_file_owner_to_parent(connection_struct *conn,
 156                                         const char *inherit_from_dir,
 157                                         files_struct *fsp)
 158 {
 159         SMB_STRUCT_STAT parent_st;
 160         int ret;
 161
 162         ret = SMB_VFS_STAT(conn, inherit_from_dir, &parent_st);
 163         if (ret == -1) {
 164                 DEBUG(0,("change_file_owner_to_parent: failed to stat parent "
 165                          "directory %s. Error was %s\n",
 166                          inherit_from_dir, strerror(errno) ));
 167                 return;
 168         }
 169
 170         become_root();
 171         ret = SMB_VFS_FCHOWN(fsp, parent_st.st_uid, (gid_t)-1);
 172         unbecome_root();
 173         if (ret == -1) {
 174                 DEBUG(0,("change_file_owner_to_parent: failed to fchown "
 175                          "file %s to parent directory uid %u. Error "
 176                          "was %s\n", fsp->fsp_name,
 177                          (unsigned int)parent_st.st_uid,
 178                          strerror(errno) ));
 179         }
 180
 181         DEBUG(10,("change_file_owner_to_parent: changed new file %s to "
 182                   "parent directory uid %u.\n", fsp->fsp_name,
 183                   (unsigned int)parent_st.st_uid ));
 184 }
 185
 186 static NTSTATUS change_dir_owner_to_parent(connection_struct *conn,
 187                                        const char *inherit_from_dir,
 188                                        const char *fname,
 189                                        SMB_STRUCT_STAT *psbuf)
 190 {
 191         char *saved_dir = NULL;
 192         SMB_STRUCT_STAT sbuf;
 193         SMB_STRUCT_STAT parent_st;
 194         TALLOC_CTX *ctx = talloc_tos();
 195         NTSTATUS status = NT_STATUS_OK;
 196         int ret;
 197
 198         ret = SMB_VFS_STAT(conn, inherit_from_dir, &parent_st);
 199         if (ret == -1) {
 200                 status = map_nt_error_from_unix(errno);
 201                 DEBUG(0,("change_dir_owner_to_parent: failed to stat parent "
 202                          "directory %s. Error was %s\n",
 203                          inherit_from_dir, strerror(errno) ));
 204                 return status;
 205         }
 206
 207         /* We've already done an lstat into psbuf, and we know it's a
 208            directory. If we can cd into the directory and the dev/ino
 209            are the same then we can safely chown without races as
 210            we're locking the directory in place by being in it.  This
 211            should work on any UNIX (thanks tridge :-). JRA.
 212         */
 213
 214         saved_dir = vfs_GetWd(ctx,conn);
 215         if (!saved_dir) {
 216                 status = map_nt_error_from_unix(errno);
 217                 DEBUG(0,("change_dir_owner_to_parent: failed to get "
 218                          "current working directory. Error was %s\n",
 219                          strerror(errno)));
 220                 return status;
 221         }
 222
 223         /* Chdir into the new path. */
 224         if (vfs_ChDir(conn, fname) == -1) {
 225                 status = map_nt_error_from_unix(errno);
 226                 DEBUG(0,("change_dir_owner_to_parent: failed to change "
 227                          "current working directory to %s. Error "
 228                          "was %s\n", fname, strerror(errno) ));
 229                 goto out;
 230         }
 231
 232         if (SMB_VFS_STAT(conn,".",&sbuf) == -1) {
 233                 status = map_nt_error_from_unix(errno);
 234                 DEBUG(0,("change_dir_owner_to_parent: failed to stat "
 235                          "directory '.' (%s) Error was %s\n",
 236                          fname, strerror(errno)));
 237                 goto out;
 238         }
 239
 240         /* Ensure we're pointing at the same place. */
 241         if (sbuf.st_dev != psbuf->st_dev ||
 242             sbuf.st_ino != psbuf->st_ino ||
 243             sbuf.st_mode != psbuf->st_mode ) {
 244                 DEBUG(0,("change_dir_owner_to_parent: "
 245                          "device/inode/mode on directory %s changed. "
 246                          "Refusing to chown !\n", fname ));
 247                 status = NT_STATUS_ACCESS_DENIED;
 248                 goto out;
 249         }
 250
 251         become_root();
 252         ret = SMB_VFS_CHOWN(conn, ".", parent_st.st_uid, (gid_t)-1);
 253         unbecome_root();
 254         if (ret == -1) {
 255                 status = map_nt_error_from_unix(errno);
 256                 DEBUG(10,("change_dir_owner_to_parent: failed to chown "
 257                           "directory %s to parent directory uid %u. "
 258                           "Error was %s\n", fname,
 259                           (unsigned int)parent_st.st_uid, strerror(errno) ));
 260                 goto out;
 261         }
 262
 263         DEBUG(10,("change_dir_owner_to_parent: changed ownership of new "
 264                   "directory %s to parent directory uid %u.\n",
 265                   fname, (unsigned int)parent_st.st_uid ));
 266
 267  out:
 268
 269         vfs_ChDir(conn,saved_dir);
 270         return status;
 271 }
 272
 273 /****************************************************************************
 274  Open a file.
 275 ****************************************************************************/
 276
 277 static NTSTATUS open_file(files_struct *fsp,
 278                           connection_struct *conn,
 279                           struct smb_request *req,
 280                           const char *parent_dir,
 281                           const char *name,
 282                           const char *path,
 283                           SMB_STRUCT_STAT *psbuf,
 284                           int flags,
 285                           mode_t unx_mode,
 286                           uint32 access_mask, /* client requested access mask. */
 287                           uint32 open_access_mask) /* what we're actually using in the open. */
 288 {
 289         NTSTATUS status = NT_STATUS_OK;
 290         int accmode = (flags & O_ACCMODE);
 291         int local_flags = flags;
 292         bool file_existed = VALID_STAT(*psbuf);
 293
 294         fsp->fh->fd = -1;
 295         errno = EPERM;
 296
 297         /* Check permissions */
 298
 299         /*
 300          * This code was changed after seeing a client open request
 301          * containing the open mode of (DENY_WRITE/read-only) with
 302          * the 'create if not exist' bit set. The previous code
 303          * would fail to open the file read only on a read-only share
 304          * as it was checking the flags parameter  directly against O_RDONLY,
 305          * this was failing as the flags parameter was set to O_RDONLY|O_CREAT.
 306          * JRA.
 307          */
 308
 309         if (!CAN_WRITE(conn)) {
 310                 /* It's a read-only share - fail if we wanted to write. */
 311                 if(accmode != O_RDONLY) {
 312                         DEBUG(3,("Permission denied opening %s\n", path));
 313                         return NT_STATUS_ACCESS_DENIED;
 314                 } else if(flags & O_CREAT) {
 315                         /* We don't want to write - but we must make sure that
 316                            O_CREAT doesn't create the file if we have write
 317                            access into the directory.
 318                         */
 319                         flags &= ~O_CREAT;
 320                         local_flags &= ~O_CREAT;
 321                 }
 322         }
 323
 324         /*
 325          * This little piece of insanity is inspired by the
 326          * fact that an NT client can open a file for O_RDONLY,
 327          * but set the create disposition to FILE_EXISTS_TRUNCATE.
 328          * If the client *can* write to the file, then it expects to
 329          * truncate the file, even though it is opening for readonly.
 330          * Quicken uses this stupid trick in backup file creation...
 331          * Thanks *greatly* to "David W. Chapman Jr." <dwcjr@inethouston.net>
 332          * for helping track this one down. It didn't bite us in 2.0.x
 333          * as we always opened files read-write in that release. JRA.
 334          */
 335
 336         if ((accmode == O_RDONLY) && ((flags & O_TRUNC) == O_TRUNC)) {
 337                 DEBUG(10,("open_file: truncate requested on read-only open "
 338                           "for file %s\n", path));
 339                 local_flags = (flags & ~O_ACCMODE)|O_RDWR;
 340         }
 341
 342         if ((open_access_mask & (FILE_READ_DATA|FILE_WRITE_DATA|FILE_APPEND_DATA|FILE_EXECUTE)) ||
 343             (!file_existed && (local_flags & O_CREAT)) ||
 344             ((local_flags & O_TRUNC) == O_TRUNC) ) {
 345                 const char *wild;
 346
 347                 /*
 348                  * We can't actually truncate here as the file may be locked.
 349                  * open_file_ntcreate will take care of the truncate later. JRA.
 350                  */
 351
 352                 local_flags &= ~O_TRUNC;
 353
 354 #if defined(O_NONBLOCK) && defined(S_ISFIFO)
 355                 /*
 356                  * We would block on opening a FIFO with no one else on the
 357                  * other end. Do what we used to do and add O_NONBLOCK to the
 358                  * open flags. JRA.
 359                  */
 360
 361                 if (file_existed && S_ISFIFO(psbuf->st_mode)) {
 362                         local_flags |= O_NONBLOCK;
 363                 }
 364 #endif
 365
 366                 /* Don't create files with Microsoft wildcard characters. */
 367                 if (fsp->base_fsp) {
 368                         /*
 369                          * wildcard characters are allowed in stream names
 370                          * only test the basefilename
 371                          */
 372                         wild = fsp->base_fsp->fsp_name;
 373                 } else {
 374                         wild = path;
 375                 }
 376                 if ((local_flags & O_CREAT) && !file_existed &&
 377                     ms_has_wild(wild))  {
 378                         return NT_STATUS_OBJECT_NAME_INVALID;
 379                 }
 380
 381                 /* Actually do the open */
 382                 status = fd_open(conn, path, fsp, local_flags, unx_mode);
 383                 if (!NT_STATUS_IS_OK(status)) {
 384                         DEBUG(3,("Error opening file %s (%s) (local_flags=%d) "
 385                                  "(flags=%d)\n",
 386                                  path,nt_errstr(status),local_flags,flags));
 387                         return status;
 388                 }
 389
 390                 if ((local_flags & O_CREAT) && !file_existed) {
 391
 392                         /* Inherit the ACL if required */
 393                         if (lp_inherit_perms(SNUM(conn))) {
 394                                 inherit_access_posix_acl(conn, parent_dir, path,
 395                                                    unx_mode);
 396                         }
 397
 398                         /* Change the owner if required. */
 399                         if (lp_inherit_owner(SNUM(conn))) {
 400                                 change_file_owner_to_parent(conn, parent_dir,
 401                                                             fsp);
 402                         }
 403
 404                         notify_fname(conn, NOTIFY_ACTION_ADDED,
 405                                      FILE_NOTIFY_CHANGE_FILE_NAME, path);
 406                 }
 407
 408         } else {
 409                 fsp->fh->fd = -1; /* What we used to call a stat open. */
 410                 if (file_existed) {
 411                         uint32_t access_granted = 0;
 412
 413                         status = check_open_rights(conn,
 414                                         path,
 415                                         access_mask,
 416                                         &access_granted);
 417                         if (!NT_STATUS_IS_OK(status)) {
 418
 419                                 /* Were we trying to do a stat open
 420                                  * for delete and didn't get DELETE
 421                                  * access (only) ? Check if the
 422                                  * directory allows DELETE_CHILD.
 423                                  * See here:
 424                                  * http://blogs.msdn.com/oldnewthing/archive/2004/06/04/148426.aspx
 425                                  * for details. */
 426
 427                                 if (!(NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED) &&
 428                                                 (access_mask & DELETE_ACCESS) &&
 429                                                 (access_granted == DELETE_ACCESS) &&
 430                                                 can_delete_file_in_directory(conn, path))) {
 431                                         DEBUG(10, ("open_file: Access denied on "
 432                                                 "file %s\n",
 433                                                 path));
 434                                         return status;
 435                                 }
 436
 437                                 DEBUG(10,("open_file: overrode ACCESS_DENIED "
 438                                         "on file %s\n",
 439                                         path ));
 440                         }
 441                 }
 442         }
 443
 444         if (!file_existed) {
 445                 int ret;
 446
 447                 if (fsp->fh->fd == -1) {
 448                         ret = SMB_VFS_STAT(conn, path, psbuf);
 449                 } else {
 450                         ret = SMB_VFS_FSTAT(fsp, psbuf);
 451                         /* If we have an fd, this stat should succeed. */
 452                         if (ret == -1) {
 453                                 DEBUG(0,("Error doing fstat on open file %s "
 454                                          "(%s)\n", path,strerror(errno) ));
 455                         }
 456                 }
 457
 458                 /* For a non-io open, this stat failing means file not found. JRA */
 459                 if (ret == -1) {
 460                         status = map_nt_error_from_unix(errno);
 461                         fd_close(fsp);
 462                         return status;
 463                 }
 464         }
 465
 466         /*
 467          * POSIX allows read-only opens of directories. We don't
 468          * want to do this (we use a different code path for this)
 469          * so catch a directory open and return an EISDIR. JRA.
 470          */
 471
 472         if(S_ISDIR(psbuf->st_mode)) {
 473                 fd_close(fsp);
 474                 errno = EISDIR;
 475                 return NT_STATUS_FILE_IS_A_DIRECTORY;
 476         }
 477
 478         fsp->mode = psbuf->st_mode;
 479         fsp->file_id = vfs_file_id_from_sbuf(conn, psbuf);
 480         fsp->vuid = req ? req->vuid : UID_FIELD_INVALID;
 481         fsp->file_pid = req ? req->smbpid : 0;
 482         fsp->can_lock = True;
 483         fsp->can_read = (access_mask & (FILE_READ_DATA)) ? True : False;
 484         if (!CAN_WRITE(conn)) {
 485                 fsp->can_write = False;
 486         } else {
 487                 fsp->can_write = (access_mask & (FILE_WRITE_DATA | FILE_APPEND_DATA)) ?
 488                         True : False;
 489         }
 490         fsp->print_file = False;
 491         fsp->modified = False;
 492         fsp->sent_oplock_break = NO_BREAK_SENT;
 493         fsp->is_directory = False;
 494         if (conn->aio_write_behind_list &&
 495             is_in_path(path, conn->aio_write_behind_list, conn->case_sensitive)) {
 496                 fsp->aio_write_behind = True;
 497         }
 498
 499         string_set(&fsp->fsp_name, path);
 500         fsp->wcp = NULL; /* Write cache pointer. */
 501
 502         DEBUG(2,("%s opened file %s read=%s write=%s (numopen=%d)\n",
 503                  conn->server_info->unix_name,
 504                  fsp->fsp_name,
 505                  BOOLSTR(fsp->can_read), BOOLSTR(fsp->can_write),
 506                  conn->num_files_open));
 507
 508         errno = 0;
 509         return NT_STATUS_OK;
 510 }
 511
 512 /*******************************************************************
 513  Return True if the filename is one of the special executable types.
 514 ********************************************************************/
 515
 516 static bool is_executable(const char *fname)
 517 {
 518         if ((fname = strrchr_m(fname,'.'))) {
 519                 if (strequal(fname,".com") ||
 520                     strequal(fname,".dll") ||
 521                     strequal(fname,".exe") ||
 522                     strequal(fname,".sym")) {
 523                         return True;
 524                 }
 525         }
 526         return False;
 527 }
 528
 529 /****************************************************************************
 530  Check if we can open a file with a share mode.
 531  Returns True if conflict, False if not.
 532 ****************************************************************************/
 533
 534 static bool share_conflict(struct share_mode_entry *entry,
 535                            uint32 access_mask,
 536                            uint32 share_access)
 537 {
 538         DEBUG(10,("share_conflict: entry->access_mask = 0x%x, "
 539                   "entry->share_access = 0x%x, "
 540                   "entry->private_options = 0x%x\n",
 541                   (unsigned int)entry->access_mask,
 542                   (unsigned int)entry->share_access,
 543                   (unsigned int)entry->private_options));
 544
 545         DEBUG(10,("share_conflict: access_mask = 0x%x, share_access = 0x%x\n",
 546                   (unsigned int)access_mask, (unsigned int)share_access));
 547
 548         if ((entry->access_mask & (FILE_WRITE_DATA|
 549                                    FILE_APPEND_DATA|
 550                                    FILE_READ_DATA|
 551                                    FILE_EXECUTE|
 552                                    DELETE_ACCESS)) == 0) {
 553                 DEBUG(10,("share_conflict: No conflict due to "
 554                           "entry->access_mask = 0x%x\n",
 555                           (unsigned int)entry->access_mask ));
 556                 return False;
 557         }
 558
 559         if ((access_mask & (FILE_WRITE_DATA|
 560                             FILE_APPEND_DATA|
 561                             FILE_READ_DATA|
 562                             FILE_EXECUTE|
 563                             DELETE_ACCESS)) == 0) {
 564                 DEBUG(10,("share_conflict: No conflict due to "
 565                           "access_mask = 0x%x\n",
 566                           (unsigned int)access_mask ));
 567                 return False;
 568         }
 569
 570 #if 1 /* JRA TEST - Superdebug. */
 571 #define CHECK_MASK(num, am, right, sa, share) \
 572         DEBUG(10,("share_conflict: [%d] am (0x%x) & right (0x%x) = 0x%x\n", \
 573                 (unsigned int)(num), (unsigned int)(am), \
 574                 (unsigned int)(right), (unsigned int)(am)&(right) )); \
 575         DEBUG(10,("share_conflict: [%d] sa (0x%x) & share (0x%x) = 0x%x\n", \
 576                 (unsigned int)(num), (unsigned int)(sa), \
 577                 (unsigned int)(share), (unsigned int)(sa)&(share) )); \
 578         if (((am) & (right)) && !((sa) & (share))) { \
 579                 DEBUG(10,("share_conflict: check %d conflict am = 0x%x, right = 0x%x, \
 580 sa = 0x%x, share = 0x%x\n", (num), (unsigned int)(am), (unsigned int)(right), (unsigned int)(sa), \
 581                         (unsigned int)(share) )); \
 582                 return True; \
 583         }
 584 #else
 585 #define CHECK_MASK(num, am, right, sa, share) \
 586         if (((am) & (right)) && !((sa) & (share))) { \
 587                 DEBUG(10,("share_conflict: check %d conflict am = 0x%x, right = 0x%x, \
 588 sa = 0x%x, share = 0x%x\n", (num), (unsigned int)(am), (unsigned int)(right), (unsigned int)(sa), \
 589                         (unsigned int)(share) )); \
 590                 return True; \
 591         }
 592 #endif
 593
 594         CHECK_MASK(1, entry->access_mask, FILE_WRITE_DATA | FILE_APPEND_DATA,
 595                    share_access, FILE_SHARE_WRITE);
 596         CHECK_MASK(2, access_mask, FILE_WRITE_DATA | FILE_APPEND_DATA,
 597                    entry->share_access, FILE_SHARE_WRITE);
 598
 599         CHECK_MASK(3, entry->access_mask, FILE_READ_DATA | FILE_EXECUTE,
 600                    share_access, FILE_SHARE_READ);
 601         CHECK_MASK(4, access_mask, FILE_READ_DATA | FILE_EXECUTE,
 602                    entry->share_access, FILE_SHARE_READ);
 603
 604         CHECK_MASK(5, entry->access_mask, DELETE_ACCESS,
 605                    share_access, FILE_SHARE_DELETE);
 606         CHECK_MASK(6, access_mask, DELETE_ACCESS,
 607                    entry->share_access, FILE_SHARE_DELETE);
 608
 609         DEBUG(10,("share_conflict: No conflict.\n"));
 610         return False;
 611 }
 612
 613 #if defined(DEVELOPER)
 614 static void validate_my_share_entries(int num,
 615                                       struct share_mode_entry *share_entry)
 616 {
 617         files_struct *fsp;
 618
 619         if (!procid_is_me(&share_entry->pid)) {
 620                 return;
 621         }
 622
 623         if (is_deferred_open_entry(share_entry) &&
 624             !open_was_deferred(share_entry->op_mid)) {
 625                 char *str = talloc_asprintf(talloc_tos(),
 626                         "Got a deferred entry without a request: "
 627                         "PANIC: %s\n",
 628                         share_mode_str(talloc_tos(), num, share_entry));
 629                 smb_panic(str);
 630         }
 631
 632         if (!is_valid_share_mode_entry(share_entry)) {
 633                 return;
 634         }
 635
 636         fsp = file_find_dif(share_entry->id,
 637                             share_entry->share_file_id);
 638         if (!fsp) {
 639                 DEBUG(0,("validate_my_share_entries: PANIC : %s\n",
 640                          share_mode_str(talloc_tos(), num, share_entry) ));
 641                 smb_panic("validate_my_share_entries: Cannot match a "
 642                           "share entry with an open file\n");
 643         }
 644
 645         if (is_deferred_open_entry(share_entry) ||
 646             is_unused_share_mode_entry(share_entry)) {
 647                 goto panic;
 648         }
 649
 650         if ((share_entry->op_type == NO_OPLOCK) &&
 651             (fsp->oplock_type == FAKE_LEVEL_II_OPLOCK)) {
 652                 /* Someone has already written to it, but I haven't yet
 653                  * noticed */
 654                 return;
 655         }
 656
 657         if (((uint16)fsp->oplock_type) != share_entry->op_type) {
 658                 goto panic;
 659         }
 660
 661         return;
 662
 663  panic:
 664         {
 665                 char *str;
 666                 DEBUG(0,("validate_my_share_entries: PANIC : %s\n",
 667                          share_mode_str(talloc_tos(), num, share_entry) ));
 668                 str = talloc_asprintf(talloc_tos(),
 669                         "validate_my_share_entries: "
 670                         "file %s, oplock_type = 0x%x, op_type = 0x%x\n",
 671                          fsp->fsp_name, (unsigned int)fsp->oplock_type,
 672                          (unsigned int)share_entry->op_type );
 673                 smb_panic(str);
 674         }
 675 }
 676 #endif
 677
 678 static bool is_stat_open(uint32 access_mask)
 679 {
 680         return (access_mask &&
 681                 ((access_mask & ~(SYNCHRONIZE_ACCESS| FILE_READ_ATTRIBUTES|
 682                                   FILE_WRITE_ATTRIBUTES))==0) &&
 683                 ((access_mask & (SYNCHRONIZE_ACCESS|FILE_READ_ATTRIBUTES|
 684                                  FILE_WRITE_ATTRIBUTES)) != 0));
 685 }
 686
 687 /****************************************************************************
 688  Deal with share modes
 689  Invarient: Share mode must be locked on entry and exit.
 690  Returns -1 on error, or number of share modes on success (may be zero).
 691 ****************************************************************************/
 692
 693 static NTSTATUS open_mode_check(connection_struct *conn,
 694                                 const char *fname,
 695                                 struct share_mode_lock *lck,
 696                                 uint32 access_mask,
 697                                 uint32 share_access,
 698                                 uint32 create_options,
 699                                 bool *file_existed)
 700 {
 701         int i;
 702
 703         if(lck->num_share_modes == 0) {
 704                 return NT_STATUS_OK;
 705         }
 706
 707         *file_existed = True;
 708
 709         /* A delete on close prohibits everything */
 710
 711         if (lck->delete_on_close) {
 712                 return NT_STATUS_DELETE_PENDING;
 713         }
 714
 715         if (is_stat_open(access_mask)) {
 716                 /* Stat open that doesn't trigger oplock breaks or share mode
 717                  * checks... ! JRA. */
 718                 return NT_STATUS_OK;
 719         }
 720
 721         /*
 722          * Check if the share modes will give us access.
 723          */
 724
 725 #if defined(DEVELOPER)
 726         for(i = 0; i < lck->num_share_modes; i++) {
 727                 validate_my_share_entries(i, &lck->share_modes[i]);
 728         }
 729 #endif
 730
 731         if (!lp_share_modes(SNUM(conn))) {
 732                 return NT_STATUS_OK;
 733         }
 734
 735         /* Now we check the share modes, after any oplock breaks. */
 736         for(i = 0; i < lck->num_share_modes; i++) {
 737
 738                 if (!is_valid_share_mode_entry(&lck->share_modes[i])) {
 739                         continue;
 740                 }
 741
 742                 /* someone else has a share lock on it, check to see if we can
 743                  * too */
 744                 if (share_conflict(&lck->share_modes[i],
 745                                    access_mask, share_access)) {
 746                         return NT_STATUS_SHARING_VIOLATION;
 747                 }
 748         }
 749
 750         return NT_STATUS_OK;
 751 }
 752
 753 static bool is_delete_request(files_struct *fsp) {
 754         return ((fsp->access_mask == DELETE_ACCESS) &&
 755                 (fsp->oplock_type == NO_OPLOCK));
 756 }
 757
 758 /*
 759  * Send a break message to the oplock holder and delay the open for
 760  * our client.
 761  */
 762
 763 static NTSTATUS send_break_message(files_struct *fsp,
 764                                         struct share_mode_entry *exclusive,
 765                                         uint16 mid,
 766                                         int oplock_request)
 767 {
 768         NTSTATUS status;
 769         char msg[MSG_SMB_SHARE_MODE_ENTRY_SIZE];
 770
 771         DEBUG(10, ("Sending break request to PID %s\n",
 772                    procid_str_static(&exclusive->pid)));
 773         exclusive->op_mid = mid;
 774
 775         /* Create the message. */
 776         share_mode_entry_to_message(msg, exclusive);
 777
 778         /* Add in the FORCE_OPLOCK_BREAK_TO_NONE bit in the message if set. We
 779            don't want this set in the share mode struct pointed to by lck. */
 780
 781         if (oplock_request & FORCE_OPLOCK_BREAK_TO_NONE) {
 782                 SSVAL(msg,6,exclusive->op_type | FORCE_OPLOCK_BREAK_TO_NONE);
 783         }
 784
 785         status = messaging_send_buf(smbd_messaging_context(), exclusive->pid,
 786                                     MSG_SMB_BREAK_REQUEST,
 787                                     (uint8 *)msg,
 788                                     MSG_SMB_SHARE_MODE_ENTRY_SIZE);
 789         if (!NT_STATUS_IS_OK(status)) {
 790                 DEBUG(3, ("Could not send oplock break message: %s\n",
 791                           nt_errstr(status)));
 792         }
 793
 794         return status;
 795 }
 796
 797 /*
 798  * 1) No files open at all or internal open: Grant whatever the client wants.
 799  *
 800  * 2) Exclusive (or batch) oplock around: If the requested access is a delete
 801  *    request, break if the oplock around is a batch oplock. If it's another
 802  *    requested access type, break.
 803  *
 804  * 3) Only level2 around: Grant level2 and do nothing else.
 805  */
 806
 807 static bool delay_for_oplocks(struct share_mode_lock *lck,
 808                               files_struct *fsp,
 809                               uint16 mid,
 810                               int pass_number,
 811                               int oplock_request)
 812 {
 813         extern uint32 global_client_caps;
 814         int i;
 815         struct share_mode_entry *exclusive = NULL;
 816         bool valid_entry = false;
 817         bool have_level2 = false;
 818         bool have_a_none_oplock = false;
 819         bool allow_level2 = (global_client_caps & CAP_LEVEL_II_OPLOCKS) &&
 820                             lp_level2_oplocks(SNUM(fsp->conn));
 821
 822         if (oplock_request & INTERNAL_OPEN_ONLY) {
 823                 fsp->oplock_type = NO_OPLOCK;
 824         }
 825
 826         if ((oplock_request & INTERNAL_OPEN_ONLY) || is_stat_open(fsp->access_mask)) {
 827                 return false;
 828         }
 829
 830         for (i=0; i<lck->num_share_modes; i++) {
 831
 832                 if (!is_valid_share_mode_entry(&lck->share_modes[i])) {
 833                         continue;
 834                 }
 835
 836                 /* At least one entry is not an invalid or deferred entry. */
 837                 valid_entry = true;
 838
 839                 if (pass_number == 1) {
 840                         if (BATCH_OPLOCK_TYPE(lck->share_modes[i].op_type)) {
 841                                 SMB_ASSERT(exclusive == NULL);
 842                                 exclusive = &lck->share_modes[i];
 843                         }
 844                 } else {
 845                         if (EXCLUSIVE_OPLOCK_TYPE(lck->share_modes[i].op_type)) {
 846                                 SMB_ASSERT(exclusive == NULL);
 847                                 exclusive = &lck->share_modes[i];
 848                         }
 849                 }
 850
 851                 if (LEVEL_II_OPLOCK_TYPE(lck->share_modes[i].op_type)) {
 852                         SMB_ASSERT(exclusive == NULL);
 853                         have_level2 = true;
 854                 }
 855
 856                 if (lck->share_modes[i].op_type == NO_OPLOCK) {
 857                         have_a_none_oplock = true;
 858                 }
 859         }
 860
 861         if (exclusive != NULL) { /* Found an exclusive oplock */
 862                 bool delay_it = is_delete_request(fsp) ?
 863                                 BATCH_OPLOCK_TYPE(exclusive->op_type) : true;
 864                 SMB_ASSERT(!have_level2);
 865                 if (delay_it) {
 866                         send_break_message(fsp, exclusive, mid, oplock_request);
 867                         return true;
 868                 }
 869         }
 870
 871         /*
 872          * Match what was requested (fsp->oplock_type) with
 873          * what was found in the existing share modes.
 874          */
 875
 876         if (!valid_entry) {
 877                 /* All entries are placeholders or deferred.
 878                  * Directly grant whatever the client wants. */
 879                 if (fsp->oplock_type == NO_OPLOCK) {
 880                         /* Store a level2 oplock, but don't tell the client */
 881                         fsp->oplock_type = FAKE_LEVEL_II_OPLOCK;
 882                 }
 883         } else if (have_a_none_oplock) {
 884                 fsp->oplock_type = NO_OPLOCK;
 885         } else if (have_level2) {
 886                 if (fsp->oplock_type == NO_OPLOCK ||
 887                                 fsp->oplock_type == FAKE_LEVEL_II_OPLOCK) {
 888                         /* Store a level2 oplock, but don't tell the client */
 889                         fsp->oplock_type = FAKE_LEVEL_II_OPLOCK;
 890                 } else {
 891                         fsp->oplock_type = LEVEL_II_OPLOCK;
 892                 }
 893         } else {
 894                 /* This case can never happen. */
 895                 SMB_ASSERT(1);
 896         }
 897
 898         /*
 899          * Don't grant level2 to clients that don't want them
 900          * or if we've turned them off.
 901          */
 902         if (fsp->oplock_type == LEVEL_II_OPLOCK && !allow_level2) {
 903                 fsp->oplock_type = FAKE_LEVEL_II_OPLOCK;
 904         }
 905
 906         DEBUG(10,("delay_for_oplocks: oplock type 0x%x on file %s\n",
 907                 fsp->oplock_type, fsp->fsp_name));
 908
 909         /* No delay. */
 910         return false;
 911 }
 912
 913 static bool request_timed_out(struct timeval request_time,
 914                               struct timeval timeout)
 915 {
 916         struct timeval now, end_time;
 917         GetTimeOfDay(&now);
 918         end_time = timeval_sum(&request_time, &timeout);
 919         return (timeval_compare(&end_time, &now) < 0);
 920 }
 921
 922 /****************************************************************************
 923  Handle the 1 second delay in returning a SHARING_VIOLATION error.
 924 ****************************************************************************/
 925
 926 static void defer_open(struct share_mode_lock *lck,
 927                        struct timeval request_time,
 928                        struct timeval timeout,
 929                        struct smb_request *req,
 930                        struct deferred_open_record *state)
 931 {
 932         int i;
 933
 934         /* Paranoia check */
 935
 936         for (i=0; i<lck->num_share_modes; i++) {
 937                 struct share_mode_entry *e = &lck->share_modes[i];
 938
 939                 if (!is_deferred_open_entry(e)) {
 940                         continue;
 941                 }
 942
 943                 if (procid_is_me(&e->pid) && (e->op_mid == req->mid)) {
 944                         DEBUG(0, ("Trying to defer an already deferred "
 945                                   "request: mid=%d, exiting\n", req->mid));
 946                         exit_server("attempt to defer a deferred request");
 947                 }
 948         }
 949
 950         /* End paranoia check */
 951
 952         DEBUG(10,("defer_open_sharing_error: time [%u.%06u] adding deferred "
 953                   "open entry for mid %u\n",
 954                   (unsigned int)request_time.tv_sec,
 955                   (unsigned int)request_time.tv_usec,
 956                   (unsigned int)req->mid));
 957
 958         if (!push_deferred_smb_message(req, request_time, timeout,
 959                                        (char *)state, sizeof(*state))) {
 960                 exit_server("push_deferred_smb_message failed");
 961         }
 962         add_deferred_open(lck, req->mid, request_time, state->id);
 963
 964         /*
 965          * Push the MID of this packet on the signing queue.
 966          * We only do this once, the first time we push the packet
 967          * onto the deferred open queue, as this has a side effect
 968          * of incrementing the response sequence number.
 969          */
 970
 971         srv_defer_sign_response(req->mid);
 972 }
 973
 974
 975 /****************************************************************************
 976  On overwrite open ensure that the attributes match.
 977 ****************************************************************************/
 978
 979 static bool open_match_attributes(connection_struct *conn,
 980                                   const char *path,
 981                                   uint32 old_dos_attr,
 982                                   uint32 new_dos_attr,
 983                                   mode_t existing_unx_mode,
 984                                   mode_t new_unx_mode,
 985                                   mode_t *returned_unx_mode)
 986 {
 987         uint32 noarch_old_dos_attr, noarch_new_dos_attr;
 988
 989         noarch_old_dos_attr = (old_dos_attr & ~FILE_ATTRIBUTE_ARCHIVE);
 990         noarch_new_dos_attr = (new_dos_attr & ~FILE_ATTRIBUTE_ARCHIVE);
 991
 992         if((noarch_old_dos_attr == 0 && noarch_new_dos_attr != 0) ||
 993            (noarch_old_dos_attr != 0 && ((noarch_old_dos_attr & noarch_new_dos_attr) == noarch_old_dos_attr))) {
 994                 *returned_unx_mode = new_unx_mode;
 995         } else {
 996                 *returned_unx_mode = (mode_t)0;
 997         }
 998
 999         DEBUG(10,("open_match_attributes: file %s old_dos_attr = 0x%x, "
1000                   "existing_unx_mode = 0%o, new_dos_attr = 0x%x "
1001                   "returned_unx_mode = 0%o\n",
1002                   path,
1003                   (unsigned int)old_dos_attr,
1004                   (unsigned int)existing_unx_mode,
1005                   (unsigned int)new_dos_attr,
1006                   (unsigned int)*returned_unx_mode ));
1007
1008         /* If we're mapping SYSTEM and HIDDEN ensure they match. */
1009         if (lp_map_system(SNUM(conn)) || lp_store_dos_attributes(SNUM(conn))) {
1010                 if ((old_dos_attr & FILE_ATTRIBUTE_SYSTEM) &&
1011                     !(new_dos_attr & FILE_ATTRIBUTE_SYSTEM)) {
1012                         return False;
1013                 }
1014         }
1015         if (lp_map_hidden(SNUM(conn)) || lp_store_dos_attributes(SNUM(conn))) {
1016                 if ((old_dos_attr & FILE_ATTRIBUTE_HIDDEN) &&
1017                     !(new_dos_attr & FILE_ATTRIBUTE_HIDDEN)) {
1018                         return False;
1019                 }
1020         }
1021         return True;
1022 }
1023
1024 /****************************************************************************
1025  Special FCB or DOS processing in the case of a sharing violation.
1026  Try and find a duplicated file handle.
1027 ****************************************************************************/
1028
1029 static NTSTATUS fcb_or_dos_open(connection_struct *conn,
1030                                      files_struct *fsp_to_dup_into,
1031                                      const char *fname,
1032                                      struct file_id id,
1033                                      uint16 file_pid,
1034                                      uint16 vuid,
1035                                      uint32 access_mask,
1036                                      uint32 share_access,
1037                                      uint32 create_options)
1038 {
1039         files_struct *fsp;
1040
1041         DEBUG(5,("fcb_or_dos_open: attempting old open semantics for "
1042                  "file %s.\n", fname ));
1043
1044         for(fsp = file_find_di_first(id); fsp;
1045             fsp = file_find_di_next(fsp)) {
1046
1047                 DEBUG(10,("fcb_or_dos_open: checking file %s, fd = %d, "
1048                           "vuid = %u, file_pid = %u, private_options = 0x%x "
1049                           "access_mask = 0x%x\n", fsp->fsp_name,
1050                           fsp->fh->fd, (unsigned int)fsp->vuid,
1051                           (unsigned int)fsp->file_pid,
1052                           (unsigned int)fsp->fh->private_options,
1053                           (unsigned int)fsp->access_mask ));
1054
1055                 if (fsp->fh->fd != -1 &&
1056                     fsp->vuid == vuid &&
1057                     fsp->file_pid == file_pid &&
1058                     (fsp->fh->private_options & (NTCREATEX_OPTIONS_PRIVATE_DENY_DOS |
1059                                                  NTCREATEX_OPTIONS_PRIVATE_DENY_FCB)) &&
1060                     (fsp->access_mask & FILE_WRITE_DATA) &&
1061                     strequal(fsp->fsp_name, fname)) {
1062                         DEBUG(10,("fcb_or_dos_open: file match\n"));
1063                         break;
1064                 }
1065         }
1066
1067         if (!fsp) {
1068                 return NT_STATUS_NOT_FOUND;
1069         }
1070
1071         /* quite an insane set of semantics ... */
1072         if (is_executable(fname) &&
1073             (fsp->fh->private_options & NTCREATEX_OPTIONS_PRIVATE_DENY_DOS)) {
1074                 DEBUG(10,("fcb_or_dos_open: file fail due to is_executable.\n"));
1075                 return NT_STATUS_INVALID_PARAMETER;
1076         }
1077
1078         /* We need to duplicate this fsp. */
1079         dup_file_fsp(fsp, access_mask, share_access,
1080                           create_options, fsp_to_dup_into);
1081
1082         return NT_STATUS_OK;
1083 }
1084
1085 /****************************************************************************
1086  Open a file with a share mode - old openX method - map into NTCreate.
1087 ****************************************************************************/
1088
1089 bool map_open_params_to_ntcreate(const char *fname, int deny_mode, int open_func,
1090                                  uint32 *paccess_mask,
1091                                  uint32 *pshare_mode,
1092                                  uint32 *pcreate_disposition,
1093                                  uint32 *pcreate_options)
1094 {
1095         uint32 access_mask;
1096         uint32 share_mode;
1097         uint32 create_disposition;
1098         uint32 create_options = FILE_NON_DIRECTORY_FILE;
1099
1100         DEBUG(10,("map_open_params_to_ntcreate: fname = %s, deny_mode = 0x%x, "
1101                   "open_func = 0x%x\n",
1102                   fname, (unsigned int)deny_mode, (unsigned int)open_func ));
1103
1104         /* Create the NT compatible access_mask. */
1105         switch (GET_OPENX_MODE(deny_mode)) {
1106                 case DOS_OPEN_EXEC: /* Implies read-only - used to be FILE_READ_DATA */
1107                 case DOS_OPEN_RDONLY:
1108                         access_mask = FILE_GENERIC_READ;
1109                         break;
1110                 case DOS_OPEN_WRONLY:
1111                         access_mask = FILE_GENERIC_WRITE;
1112                         break;
1113                 case DOS_OPEN_RDWR:
1114                 case DOS_OPEN_FCB:
1115                         access_mask = FILE_GENERIC_READ|FILE_GENERIC_WRITE;
1116                         break;
1117                 default:
1118                         DEBUG(10,("map_open_params_to_ntcreate: bad open mode = 0x%x\n",
1119                                   (unsigned int)GET_OPENX_MODE(deny_mode)));
1120                         return False;
1121         }
1122
1123         /* Create the NT compatible create_disposition. */
1124         switch (open_func) {
1125                 case OPENX_FILE_EXISTS_FAIL|OPENX_FILE_CREATE_IF_NOT_EXIST:
1126                         create_disposition = FILE_CREATE;
1127                         break;
1128
1129                 case OPENX_FILE_EXISTS_OPEN:
1130                         create_disposition = FILE_OPEN;
1131                         break;
1132
1133                 case OPENX_FILE_EXISTS_OPEN|OPENX_FILE_CREATE_IF_NOT_EXIST:
1134                         create_disposition = FILE_OPEN_IF;
1135                         break;
1136
1137                 case OPENX_FILE_EXISTS_TRUNCATE:
1138                         create_disposition = FILE_OVERWRITE;
1139                         break;
1140
1141                 case OPENX_FILE_EXISTS_TRUNCATE|OPENX_FILE_CREATE_IF_NOT_EXIST:
1142                         create_disposition = FILE_OVERWRITE_IF;
1143                         break;
1144
1145                 default:
1146                         /* From samba4 - to be confirmed. */
1147                         if (GET_OPENX_MODE(deny_mode) == DOS_OPEN_EXEC) {
1148                                 create_disposition = FILE_CREATE;
1149                                 break;
1150                         }
1151                         DEBUG(10,("map_open_params_to_ntcreate: bad "
1152                                   "open_func 0x%x\n", (unsigned int)open_func));
1153                         return False;
1154         }
1155
1156         /* Create the NT compatible share modes. */
1157         switch (GET_DENY_MODE(deny_mode)) {
1158                 case DENY_ALL:
1159                         share_mode = FILE_SHARE_NONE;
1160                         break;
1161
1162                 case DENY_WRITE:
1163                         share_mode = FILE_SHARE_READ;
1164                         break;
1165
1166                 case DENY_READ:
1167                         share_mode = FILE_SHARE_WRITE;
1168                         break;
1169
1170                 case DENY_NONE:
1171                         share_mode = FILE_SHARE_READ|FILE_SHARE_WRITE;
1172                         break;
1173
1174                 case DENY_DOS:
1175                         create_options |= NTCREATEX_OPTIONS_PRIVATE_DENY_DOS;
1176                         if (is_executable(fname)) {
1177                                 share_mode = FILE_SHARE_READ|FILE_SHARE_WRITE;
1178                         } else {
1179                                 if (GET_OPENX_MODE(deny_mode) == DOS_OPEN_RDONLY) {
1180                                         share_mode = FILE_SHARE_READ;
1181                                 } else {
1182                                         share_mode = FILE_SHARE_NONE;
1183                                 }
1184                         }
1185                         break;
1186
1187                 case DENY_FCB:
1188                         create_options |= NTCREATEX_OPTIONS_PRIVATE_DENY_FCB;
1189                         share_mode = FILE_SHARE_NONE;
1190                         break;
1191
1192                 default:
1193                         DEBUG(10,("map_open_params_to_ntcreate: bad deny_mode 0x%x\n",
1194                                 (unsigned int)GET_DENY_MODE(deny_mode) ));
1195                         return False;
1196         }
1197
1198         DEBUG(10,("map_open_params_to_ntcreate: file %s, access_mask = 0x%x, "
1199                   "share_mode = 0x%x, create_disposition = 0x%x, "
1200                   "create_options = 0x%x\n",
1201                   fname,
1202                   (unsigned int)access_mask,
1203                   (unsigned int)share_mode,
1204                   (unsigned int)create_disposition,
1205                   (unsigned int)create_options ));
1206
1207         if (paccess_mask) {
1208                 *paccess_mask = access_mask;
1209         }
1210         if (pshare_mode) {
1211                 *pshare_mode = share_mode;
1212         }
1213         if (pcreate_disposition) {
1214                 *pcreate_disposition = create_disposition;
1215         }
1216         if (pcreate_options) {
1217                 *pcreate_options = create_options;
1218         }
1219
1220         return True;
1221
1222 }
1223
1224 static void schedule_defer_open(struct share_mode_lock *lck,
1225                                 struct timeval request_time,
1226                                 struct smb_request *req)
1227 {
1228         struct deferred_open_record state;
1229
1230         /* This is a relative time, added to the absolute
1231            request_time value to get the absolute timeout time.
1232            Note that if this is the second or greater time we enter
1233            this codepath for this particular request mid then
1234            request_time is left as the absolute time of the *first*
1235            time this request mid was processed. This is what allows
1236            the request to eventually time out. */
1237
1238         struct timeval timeout;
1239
1240         /* Normally the smbd we asked should respond within
1241          * OPLOCK_BREAK_TIMEOUT seconds regardless of whether
1242          * the client did, give twice the timeout as a safety
1243          * measure here in case the other smbd is stuck
1244          * somewhere else. */
1245
1246         timeout = timeval_set(OPLOCK_BREAK_TIMEOUT*2, 0);
1247
1248         /* Nothing actually uses state.delayed_for_oplocks
1249            but it's handy to differentiate in debug messages
1250            between a 30 second delay due to oplock break, and
1251            a 1 second delay for share mode conflicts. */
1252
1253         state.delayed_for_oplocks = True;
1254         state.id = lck->id;
1255
1256         if (!request_timed_out(request_time, timeout)) {
1257                 defer_open(lck, request_time, timeout, req, &state);
1258         }
1259 }
1260
1261 /****************************************************************************
1262  Work out what access_mask to use from what the client sent us.
1263 ****************************************************************************/
1264
1265 static NTSTATUS calculate_access_mask(connection_struct *conn,
1266                                         const char *fname,
1267                                         bool file_existed,
1268                                         uint32_t access_mask,
1269                                         uint32_t *access_mask_out)
1270 {
1271         NTSTATUS status;
1272
1273         /*
1274          * Convert GENERIC bits to specific bits.
1275          */
1276
1277         se_map_generic(&access_mask, &file_generic_mapping);
1278
1279         /* Calculate MAXIMUM_ALLOWED_ACCESS if requested. */
1280         if (access_mask & MAXIMUM_ALLOWED_ACCESS) {
1281                 if (file_existed) {
1282
1283                         struct security_descriptor *sd;
1284                         uint32_t access_granted = 0;
1285
1286                         status = SMB_VFS_GET_NT_ACL(conn, fname,
1287                                         (OWNER_SECURITY_INFORMATION |
1288                                         GROUP_SECURITY_INFORMATION |
1289                                         DACL_SECURITY_INFORMATION),&sd);
1290
1291                         if (!NT_STATUS_IS_OK(status)) {
1292                                 DEBUG(10, ("calculate_access_mask: Could not get acl "
1293                                         "on file %s: %s\n",
1294                                         fname,
1295                                         nt_errstr(status)));
1296                                 return NT_STATUS_ACCESS_DENIED;
1297                         }
1298
1299                         status = smb1_file_se_access_check(sd,
1300                                         conn->server_info->ptok,
1301                                         access_mask,
1302                                         &access_granted);
1303
1304                         TALLOC_FREE(sd);
1305
1306                         if (!NT_STATUS_IS_OK(status)) {
1307                                 DEBUG(10, ("calculate_access_mask: Access denied on "
1308                                         "file %s: when calculating maximum access\n",
1309                                         fname));
1310                                 return NT_STATUS_ACCESS_DENIED;
1311                         }
1312
1313                         access_mask = access_granted;
1314                 } else {
1315                         access_mask = FILE_GENERIC_ALL;
1316                 }
1317         }
1318
1319         *access_mask_out = access_mask;
1320         return NT_STATUS_OK;
1321 }
1322
1323 /****************************************************************************
1324  Open a file with a share mode. Passed in an already created files_struct *.
1325 ****************************************************************************/
1326
1327 static NTSTATUS open_file_ntcreate_internal(connection_struct *conn,
1328                             struct smb_request *req,
1329                             const char *fname,
1330                             SMB_STRUCT_STAT *psbuf,
1331                             uint32 access_mask,         /* access bits (FILE_READ_DATA etc.) */
1332                             uint32 share_access,        /* share constants (FILE_SHARE_READ etc) */
1333                             uint32 create_disposition,  /* FILE_OPEN_IF etc. */
1334                             uint32 create_options,      /* options such as delete on close. */
1335                             uint32 new_dos_attributes,  /* attributes used for new file. */
1336                             int oplock_request,         /* internal Samba oplock codes. */
1337                                                         /* Information (FILE_EXISTS etc.) */
1338                             int *pinfo,
1339                             files_struct *fsp)
1340 {
1341         int flags=0;
1342         int flags2=0;
1343         bool file_existed = VALID_STAT(*psbuf);
1344         bool def_acl = False;
1345         bool posix_open = False;
1346         bool new_file_created = False;
1347         struct file_id id;
1348         NTSTATUS fsp_open = NT_STATUS_ACCESS_DENIED;
1349         mode_t new_unx_mode = (mode_t)0;
1350         mode_t unx_mode = (mode_t)0;
1351         int info;
1352         uint32 existing_dos_attributes = 0;
1353         struct pending_message_list *pml = NULL;
1354         struct timeval request_time = timeval_zero();
1355         struct share_mode_lock *lck = NULL;
1356         uint32 open_access_mask = access_mask;
1357         NTSTATUS status;
1358         int ret_flock;
1359         char *parent_dir;
1360         const char *newname;
1361
1362         ZERO_STRUCT(id);
1363
1364         if (conn->printer) {
1365                 /*
1366                  * Printers are handled completely differently.
1367                  * Most of the passed parameters are ignored.
1368                  */
1369
1370                 if (pinfo) {
1371                         *pinfo = FILE_WAS_CREATED;
1372                 }
1373
1374                 DEBUG(10, ("open_file_ntcreate: printer open fname=%s\n", fname));
1375
1376                 return print_fsp_open(conn, fname, req->vuid, fsp, psbuf);
1377         }
1378
1379         if (!parent_dirname_talloc(talloc_tos(), fname, &parent_dir,
1380                                    &newname)) {
1381                 return NT_STATUS_NO_MEMORY;
1382         }
1383
1384         if (new_dos_attributes & FILE_FLAG_POSIX_SEMANTICS) {
1385                 posix_open = True;
1386                 unx_mode = (mode_t)(new_dos_attributes & ~FILE_FLAG_POSIX_SEMANTICS);
1387                 new_dos_attributes = 0;
1388         } else {
1389                 /* We add aARCH to this as this mode is only used if the file is
1390                  * created new. */
1391                 unx_mode = unix_mode(conn, new_dos_attributes | aARCH, fname,
1392                                      parent_dir);
1393         }
1394
1395         DEBUG(10, ("open_file_ntcreate: fname=%s, dos_attrs=0x%x "
1396                    "access_mask=0x%x share_access=0x%x "
1397                    "create_disposition = 0x%x create_options=0x%x "
1398                    "unix mode=0%o oplock_request=%d\n",
1399                    fname, new_dos_attributes, access_mask, share_access,
1400                    create_disposition, create_options, unx_mode,
1401                    oplock_request));
1402
1403         if ((req == NULL) && ((oplock_request & INTERNAL_OPEN_ONLY) == 0)) {
1404                 DEBUG(0, ("No smb request but not an internal only open!\n"));
1405                 return NT_STATUS_INTERNAL_ERROR;
1406         }
1407
1408         /*
1409          * Only non-internal opens can be deferred at all
1410          */
1411
1412         if ((req != NULL)
1413             && ((pml = get_open_deferred_message(req->mid)) != NULL)) {
1414                 struct deferred_open_record *state =
1415                         (struct deferred_open_record *)pml->private_data.data;
1416
1417                 /* Remember the absolute time of the original
1418                    request with this mid. We'll use it later to
1419                    see if this has timed out. */
1420
1421                 request_time = pml->request_time;
1422
1423                 /* Remove the deferred open entry under lock. */
1424                 lck = get_share_mode_lock(talloc_tos(), state->id, NULL, NULL,
1425                                           NULL);
1426                 if (lck == NULL) {
1427                         DEBUG(0, ("could not get share mode lock\n"));
1428                 } else {
1429                         del_deferred_open_entry(lck, req->mid);
1430                         TALLOC_FREE(lck);
1431                 }
1432
1433                 /* Ensure we don't reprocess this message. */
1434                 remove_deferred_open_smb_message(req->mid);
1435         }
1436
1437         status = check_name(conn, fname);
1438         if (!NT_STATUS_IS_OK(status)) {
1439                 return status;
1440         }
1441
1442         if (!posix_open) {
1443                 new_dos_attributes &= SAMBA_ATTRIBUTES_MASK;
1444                 if (file_existed) {
1445                         existing_dos_attributes = dos_mode(conn, fname, psbuf);
1446                 }
1447         }
1448
1449         /* ignore any oplock requests if oplocks are disabled */
1450         if (!lp_oplocks(SNUM(conn)) || global_client_failed_oplock_break ||
1451             IS_VETO_OPLOCK_PATH(conn, fname)) {
1452                 /* Mask off everything except the private Samba bits. */
1453                 oplock_request &= SAMBA_PRIVATE_OPLOCK_MASK;
1454         }
1455
1456         /* this is for OS/2 long file names - say we don't support them */
1457         if (!lp_posix_pathnames() && strstr(fname,".+,;=[].")) {
1458                 /* OS/2 Workplace shell fix may be main code stream in a later
1459                  * release. */
1460                 DEBUG(5,("open_file_ntcreate: OS/2 long filenames are not "
1461                          "supported.\n"));
1462                 if (use_nt_status()) {
1463                         return NT_STATUS_OBJECT_NAME_NOT_FOUND;
1464                 }
1465                 return NT_STATUS_DOS(ERRDOS, ERRcannotopen);
1466         }
1467
1468         switch( create_disposition ) {
1469                 /*
1470                  * Currently we're using FILE_SUPERSEDE as the same as
1471                  * FILE_OVERWRITE_IF but they really are
1472                  * different. FILE_SUPERSEDE deletes an existing file
1473                  * (requiring delete access) then recreates it.
1474                  */
1475                 case FILE_SUPERSEDE:
1476                         /* If file exists replace/overwrite. If file doesn't
1477                          * exist create. */
1478                         flags2 |= (O_CREAT | O_TRUNC);
1479                         break;
1480
1481                 case FILE_OVERWRITE_IF:
1482                         /* If file exists replace/overwrite. If file doesn't
1483                          * exist create. */
1484                         flags2 |= (O_CREAT | O_TRUNC);
1485                         break;
1486
1487                 case FILE_OPEN:
1488                         /* If file exists open. If file doesn't exist error. */
1489                         if (!file_existed) {
1490                                 DEBUG(5,("open_file_ntcreate: FILE_OPEN "
1491                                          "requested for file %s and file "
1492                                          "doesn't exist.\n", fname ));
1493                                 errno = ENOENT;
1494                                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
1495                         }
1496                         break;
1497
1498                 case FILE_OVERWRITE:
1499                         /* If file exists overwrite. If file doesn't exist
1500                          * error. */
1501                         if (!file_existed) {
1502                                 DEBUG(5,("open_file_ntcreate: FILE_OVERWRITE "
1503                                          "requested for file %s and file "
1504                                          "doesn't exist.\n", fname ));
1505                                 errno = ENOENT;
1506                                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
1507                         }
1508                         flags2 |= O_TRUNC;
1509                         break;
1510
1511                 case FILE_CREATE:
1512                         /* If file exists error. If file doesn't exist
1513                          * create. */
1514                         if (file_existed) {
1515                                 DEBUG(5,("open_file_ntcreate: FILE_CREATE "
1516                                          "requested for file %s and file "
1517                                          "already exists.\n", fname ));
1518                                 if (S_ISDIR(psbuf->st_mode)) {
1519                                         errno = EISDIR;
1520                                 } else {
1521                                         errno = EEXIST;
1522                                 }
1523                                 return map_nt_error_from_unix(errno);
1524                         }
1525                         flags2 |= (O_CREAT|O_EXCL);
1526                         break;
1527
1528                 case FILE_OPEN_IF:
1529                         /* If file exists open. If file doesn't exist
1530                          * create. */
1531                         flags2 |= O_CREAT;
1532                         break;
1533
1534                 default:
1535                         return NT_STATUS_INVALID_PARAMETER;
1536         }
1537
1538         /* We only care about matching attributes on file exists and
1539          * overwrite. */
1540
1541         if (!posix_open && file_existed && ((create_disposition == FILE_OVERWRITE) ||
1542                              (create_disposition == FILE_OVERWRITE_IF))) {
1543                 if (!open_match_attributes(conn, fname,
1544                                            existing_dos_attributes,
1545                                            new_dos_attributes, psbuf->st_mode,
1546                                            unx_mode, &new_unx_mode)) {
1547                         DEBUG(5,("open_file_ntcreate: attributes missmatch "
1548                                  "for file %s (%x %x) (0%o, 0%o)\n",
1549                                  fname, existing_dos_attributes,
1550                                  new_dos_attributes,
1551                                  (unsigned int)psbuf->st_mode,
1552                                  (unsigned int)unx_mode ));
1553                         errno = EACCES;
1554                         return NT_STATUS_ACCESS_DENIED;
1555                 }
1556         }
1557
1558         status = calculate_access_mask(conn, fname, file_existed,
1559                                         access_mask,
1560                                         &access_mask);
1561         if (!NT_STATUS_IS_OK(status)) {
1562                 DEBUG(10, ("open_file_ntcreate: calculate_access_mask "
1563                         "on file %s returned %s\n",
1564                         fname,
1565                         nt_errstr(status)));
1566                 return status;
1567         }
1568
1569         open_access_mask = access_mask;
1570
1571         if ((flags2 & O_TRUNC) || (oplock_request & FORCE_OPLOCK_BREAK_TO_NONE)) {
1572                 open_access_mask |= FILE_WRITE_DATA; /* This will cause oplock breaks. */
1573         }
1574
1575         DEBUG(10, ("open_file_ntcreate: fname=%s, after mapping "
1576                    "access_mask=0x%x\n", fname, access_mask ));
1577
1578         /*
1579          * Note that we ignore the append flag as append does not
1580          * mean the same thing under DOS and Unix.
1581          */
1582
1583         if ((access_mask & (FILE_WRITE_DATA | FILE_APPEND_DATA)) ||
1584                         (oplock_request & FORCE_OPLOCK_BREAK_TO_NONE)) {
1585                 /* DENY_DOS opens are always underlying read-write on the
1586                    file handle, no matter what the requested access mask
1587                     says. */
1588                 if ((create_options & NTCREATEX_OPTIONS_PRIVATE_DENY_DOS) ||
1589                         access_mask & (FILE_READ_ATTRIBUTES|FILE_READ_DATA|FILE_READ_EA|FILE_EXECUTE)) {
1590                         flags = O_RDWR;
1591                 } else {
1592                         flags = O_WRONLY;
1593                 }
1594         } else {
1595                 flags = O_RDONLY;
1596         }
1597
1598         /*
1599          * Currently we only look at FILE_WRITE_THROUGH for create options.
1600          */
1601
1602 #if defined(O_SYNC)
1603         if ((create_options & FILE_WRITE_THROUGH) && lp_strict_sync(SNUM(conn))) {
1604                 flags2 |= O_SYNC;
1605         }
1606 #endif /* O_SYNC */
1607
1608         if (posix_open && (access_mask & FILE_APPEND_DATA)) {
1609                 flags2 |= O_APPEND;
1610         }
1611
1612         if (!posix_open && !CAN_WRITE(conn)) {
1613                 /*
1614                  * We should really return a permission denied error if either
1615                  * O_CREAT or O_TRUNC are set, but for compatibility with
1616                  * older versions of Samba we just AND them out.
1617                  */
1618                 flags2 &= ~(O_CREAT|O_TRUNC);
1619         }
1620
1621         /*
1622          * Ensure we can't write on a read-only share or file.
1623          */
1624
1625         if (flags != O_RDONLY && file_existed &&
1626             (!CAN_WRITE(conn) || IS_DOS_READONLY(existing_dos_attributes))) {
1627                 DEBUG(5,("open_file_ntcreate: write access requested for "
1628                          "file %s on read only %s\n",
1629                          fname, !CAN_WRITE(conn) ? "share" : "file" ));
1630                 errno = EACCES;
1631                 return NT_STATUS_ACCESS_DENIED;
1632         }
1633
1634         fsp->file_id = vfs_file_id_from_sbuf(conn, psbuf);
1635         fsp->share_access = share_access;
1636         fsp->fh->private_options = create_options;
1637         fsp->access_mask = open_access_mask; /* We change this to the
1638                                               * requested access_mask after
1639                                               * the open is done. */
1640         fsp->posix_open = posix_open;
1641
1642         /* Ensure no SAMBA_PRIVATE bits can be set. */
1643         fsp->oplock_type = (oplock_request & ~SAMBA_PRIVATE_OPLOCK_MASK);
1644
1645         if (timeval_is_zero(&request_time)) {
1646                 request_time = fsp->open_time;
1647         }
1648
1649         if (file_existed) {
1650                 struct timespec old_write_time = get_mtimespec(psbuf);
1651                 id = vfs_file_id_from_sbuf(conn, psbuf);
1652
1653                 lck = get_share_mode_lock(talloc_tos(), id,
1654                                           conn->connectpath,
1655                                           fname, &old_write_time);
1656
1657                 if (lck == NULL) {
1658                         DEBUG(0, ("Could not get share mode lock\n"));
1659                         return NT_STATUS_SHARING_VIOLATION;
1660                 }
1661
1662                 /* First pass - send break only on batch oplocks. */
1663                 if ((req != NULL)
1664                     && delay_for_oplocks(lck, fsp, req->mid, 1,
1665                                          oplock_request)) {
1666                         schedule_defer_open(lck, request_time, req);
1667                         TALLOC_FREE(lck);
1668                         return NT_STATUS_SHARING_VIOLATION;
1669                 }
1670
1671                 /* Use the client requested access mask here, not the one we
1672                  * open with. */
1673                 status = open_mode_check(conn, fname, lck,
1674                                          access_mask, share_access,
1675                                          create_options, &file_existed);
1676
1677                 if (NT_STATUS_IS_OK(status)) {
1678                         /* We might be going to allow this open. Check oplock
1679                          * status again. */
1680                         /* Second pass - send break for both batch or
1681                          * exclusive oplocks. */
1682                         if ((req != NULL)
1683                              && delay_for_oplocks(lck, fsp, req->mid, 2,
1684                                                   oplock_request)) {
1685                                 schedule_defer_open(lck, request_time, req);
1686                                 TALLOC_FREE(lck);
1687                                 return NT_STATUS_SHARING_VIOLATION;
1688                         }
1689                 }
1690
1691                 if (NT_STATUS_EQUAL(status, NT_STATUS_DELETE_PENDING)) {
1692                         /* DELETE_PENDING is not deferred for a second */
1693                         TALLOC_FREE(lck);
1694                         return status;
1695                 }
1696
1697                 if (!NT_STATUS_IS_OK(status)) {
1698                         uint32 can_access_mask;
1699                         bool can_access = True;
1700
1701                         SMB_ASSERT(NT_STATUS_EQUAL(status, NT_STATUS_SHARING_VIOLATION));
1702
1703                         /* Check if this can be done with the deny_dos and fcb
1704                          * calls. */
1705                         if (create_options &
1706                             (NTCREATEX_OPTIONS_PRIVATE_DENY_DOS|
1707                              NTCREATEX_OPTIONS_PRIVATE_DENY_FCB)) {
1708                                 if (req == NULL) {
1709                                         DEBUG(0, ("DOS open without an SMB "
1710                                                   "request!\n"));
1711                                         TALLOC_FREE(lck);
1712                                         return NT_STATUS_INTERNAL_ERROR;
1713                                 }
1714
1715                                 /* Use the client requested access mask here,
1716                                  * not the one we open with. */
1717                                 status = fcb_or_dos_open(conn,
1718                                                           fsp,
1719                                                           fname,
1720                                                           id,
1721                                                           req->smbpid,
1722                                                           req->vuid,
1723                                                           access_mask,
1724                                                           share_access,
1725                                                           create_options);
1726
1727                                 if (NT_STATUS_IS_OK(status)) {
1728                                         TALLOC_FREE(lck);
1729                                         if (pinfo) {
1730                                                 *pinfo = FILE_WAS_OPENED;
1731                                         }
1732                                         return NT_STATUS_OK;
1733                                 }
1734                         }
1735
1736                         /*
1737                          * This next line is a subtlety we need for
1738                          * MS-Access. If a file open will fail due to share
1739                          * permissions and also for security (access) reasons,
1740                          * we need to return the access failed error, not the
1741                          * share error. We can't open the file due to kernel
1742                          * oplock deadlock (it's possible we failed above on
1743                          * the open_mode_check()) so use a userspace check.
1744                          */
1745
1746                         if (flags & O_RDWR) {
1747                                 can_access_mask = FILE_READ_DATA|FILE_WRITE_DATA;
1748                         } else if (flags & O_WRONLY) {
1749                                 can_access_mask = FILE_WRITE_DATA;
1750                         } else {
1751                                 can_access_mask = FILE_READ_DATA;
1752                         }
1753
1754                         if (((can_access_mask & FILE_WRITE_DATA) && !CAN_WRITE(conn)) ||
1755                             !can_access_file_data(conn,fname,psbuf,can_access_mask)) {
1756                                 can_access = False;
1757                         }
1758
1759                         /*
1760                          * If we're returning a share violation, ensure we
1761                          * cope with the braindead 1 second delay.
1762                          */
1763
1764                         if (!(oplock_request & INTERNAL_OPEN_ONLY) &&
1765                             lp_defer_sharing_violations()) {
1766                                 struct timeval timeout;
1767                                 struct deferred_open_record state;
1768                                 int timeout_usecs;
1769
1770                                 /* this is a hack to speed up torture tests
1771                                    in 'make test' */
1772                                 timeout_usecs = lp_parm_int(SNUM(conn),
1773                                                             "smbd","sharedelay",
1774                                                             SHARING_VIOLATION_USEC_WAIT);
1775
1776                                 /* This is a relative time, added to the absolute
1777                                    request_time value to get the absolute timeout time.
1778                                    Note that if this is the second or greater time we enter
1779                                    this codepath for this particular request mid then
1780                                    request_time is left as the absolute time of the *first*
1781                                    time this request mid was processed. This is what allows
1782                                    the request to eventually time out. */
1783
1784                                 timeout = timeval_set(0, timeout_usecs);
1785
1786                                 /* Nothing actually uses state.delayed_for_oplocks
1787                                    but it's handy to differentiate in debug messages
1788                                    between a 30 second delay due to oplock break, and
1789                                    a 1 second delay for share mode conflicts. */
1790
1791                                 state.delayed_for_oplocks = False;
1792                                 state.id = id;
1793
1794                                 if ((req != NULL)
1795                                     && !request_timed_out(request_time,
1796                                                           timeout)) {
1797                                         defer_open(lck, request_time, timeout,
1798                                                    req, &state);
1799                                 }
1800                         }
1801
1802                         TALLOC_FREE(lck);
1803                         if (can_access) {
1804                                 /*
1805                                  * We have detected a sharing violation here
1806                                  * so return the correct error code
1807                                  */
1808                                 status = NT_STATUS_SHARING_VIOLATION;
1809                         } else {
1810                                 status = NT_STATUS_ACCESS_DENIED;
1811                         }
1812                         return status;
1813                 }
1814
1815                 /*
1816                  * We exit this block with the share entry *locked*.....
1817                  */
1818         }
1819
1820         SMB_ASSERT(!file_existed || (lck != NULL));
1821
1822         /*
1823          * Ensure we pay attention to default ACLs on directories if required.
1824          */
1825
1826         if ((flags2 & O_CREAT) && lp_inherit_acls(SNUM(conn)) &&
1827             (def_acl = directory_has_default_acl(conn, parent_dir))) {
1828                 unx_mode = 0777;
1829         }
1830
1831         DEBUG(4,("calling open_file with flags=0x%X flags2=0x%X mode=0%o, "
1832                 "access_mask = 0x%x, open_access_mask = 0x%x\n",
1833                  (unsigned int)flags, (unsigned int)flags2,
1834                  (unsigned int)unx_mode, (unsigned int)access_mask,
1835                  (unsigned int)open_access_mask));
1836
1837         /*
1838          * open_file strips any O_TRUNC flags itself.
1839          */
1840
1841         fsp_open = open_file(fsp, conn, req, parent_dir, newname, fname, psbuf,
1842                              flags|flags2, unx_mode, access_mask,
1843                              open_access_mask);
1844
1845         if (!NT_STATUS_IS_OK(fsp_open)) {
1846                 if (lck != NULL) {
1847                         TALLOC_FREE(lck);
1848                 }
1849                 return fsp_open;
1850         }
1851
1852         if (!file_existed) {
1853                 struct timespec old_write_time = get_mtimespec(psbuf);
1854                 /*
1855                  * Deal with the race condition where two smbd's detect the
1856                  * file doesn't exist and do the create at the same time. One
1857                  * of them will win and set a share mode, the other (ie. this
1858                  * one) should check if the requested share mode for this
1859                  * create is allowed.
1860                  */
1861
1862                 /*
1863                  * Now the file exists and fsp is successfully opened,
1864                  * fsp->dev and fsp->inode are valid and should replace the
1865                  * dev=0,inode=0 from a non existent file. Spotted by
1866                  * Nadav Danieli <nadavd@exanet.com>. JRA.
1867                  */
1868
1869                 id = fsp->file_id;
1870
1871                 lck = get_share_mode_lock(talloc_tos(), id,
1872                                           conn->connectpath,
1873                                           fname, &old_write_time);
1874
1875                 if (lck == NULL) {
1876                         DEBUG(0, ("open_file_ntcreate: Could not get share "
1877                                   "mode lock for %s\n", fname));
1878                         fd_close(fsp);
1879                         return NT_STATUS_SHARING_VIOLATION;
1880                 }
1881
1882                 /* First pass - send break only on batch oplocks. */
1883                 if ((req != NULL)
1884                     && delay_for_oplocks(lck, fsp, req->mid, 1,
1885                                          oplock_request)) {
1886                         schedule_defer_open(lck, request_time, req);
1887                         TALLOC_FREE(lck);
1888                         fd_close(fsp);
1889                         return NT_STATUS_SHARING_VIOLATION;
1890                 }
1891
1892                 status = open_mode_check(conn, fname, lck,
1893                                          access_mask, share_access,
1894                                          create_options, &file_existed);
1895
1896                 if (NT_STATUS_IS_OK(status)) {
1897                         /* We might be going to allow this open. Check oplock
1898                          * status again. */
1899                         /* Second pass - send break for both batch or
1900                          * exclusive oplocks. */
1901                         if ((req != NULL)
1902                             && delay_for_oplocks(lck, fsp, req->mid, 2,
1903                                                  oplock_request)) {
1904                                 schedule_defer_open(lck, request_time, req);
1905                                 TALLOC_FREE(lck);
1906                                 fd_close(fsp);
1907                                 return NT_STATUS_SHARING_VIOLATION;
1908                         }
1909                 }
1910
1911                 if (!NT_STATUS_IS_OK(status)) {
1912                         struct deferred_open_record state;
1913
1914                         fd_close(fsp);
1915
1916                         state.delayed_for_oplocks = False;
1917                         state.id = id;
1918
1919                         /* Do it all over again immediately. In the second
1920                          * round we will find that the file existed and handle
1921                          * the DELETE_PENDING and FCB cases correctly. No need
1922                          * to duplicate the code here. Essentially this is a
1923                          * "goto top of this function", but don't tell
1924                          * anybody... */
1925
1926                         if (req != NULL) {
1927                                 defer_open(lck, request_time, timeval_zero(),
1928                                            req, &state);
1929                         }
1930                         TALLOC_FREE(lck);
1931                         return status;
1932                 }
1933
1934                 /*
1935                  * We exit this block with the share entry *locked*.....
1936                  */
1937
1938         }
1939
1940         SMB_ASSERT(lck != NULL);
1941
1942         /* note that we ignore failure for the following. It is
1943            basically a hack for NFS, and NFS will never set one of
1944            these only read them. Nobody but Samba can ever set a deny
1945            mode and we have already checked our more authoritative
1946            locking database for permission to set this deny mode. If
1947            the kernel refuses the operations then the kernel is wrong.
1948            note that GPFS supports it as well - jmcd */
1949
1950         if (fsp->fh->fd != -1) {
1951                 ret_flock = SMB_VFS_KERNEL_FLOCK(fsp, share_access);
1952                 if(ret_flock == -1 ){
1953
1954                         TALLOC_FREE(lck);
1955                         fd_close(fsp);
1956
1957                         return NT_STATUS_SHARING_VIOLATION;
1958                 }
1959         }
1960
1961         /*
1962          * At this point onwards, we can guarentee that the share entry
1963          * is locked, whether we created the file or not, and that the
1964          * deny mode is compatible with all current opens.
1965          */
1966
1967         /*
1968          * If requested, truncate the file.
1969          */
1970
1971         if (flags2&O_TRUNC) {
1972                 /*
1973                  * We are modifing the file after open - update the stat
1974                  * struct..
1975                  */
1976                 if ((SMB_VFS_FTRUNCATE(fsp, 0) == -1) ||
1977                     (SMB_VFS_FSTAT(fsp, psbuf)==-1)) {
1978                         status = map_nt_error_from_unix(errno);
1979                         TALLOC_FREE(lck);
1980                         fd_close(fsp);
1981                         return status;
1982                 }
1983         }
1984
1985         /* Record the options we were opened with. */
1986         fsp->share_access = share_access;
1987         fsp->fh->private_options = create_options;
1988         /*
1989          * According to Samba4, SEC_FILE_READ_ATTRIBUTE is always granted,
1990          */
1991         fsp->access_mask = access_mask | FILE_READ_ATTRIBUTES;
1992
1993         if (file_existed) {
1994                 /* stat opens on existing files don't get oplocks. */
1995                 if (is_stat_open(open_access_mask)) {
1996                         fsp->oplock_type = NO_OPLOCK;
1997                 }
1998
1999                 if (!(flags2 & O_TRUNC)) {
2000                         info = FILE_WAS_OPENED;
2001                 } else {
2002                         info = FILE_WAS_OVERWRITTEN;
2003                 }
2004         } else {
2005                 info = FILE_WAS_CREATED;
2006         }
2007
2008         if (pinfo) {
2009                 *pinfo = info;
2010         }
2011
2012         /*
2013          * Setup the oplock info in both the shared memory and
2014          * file structs.
2015          */
2016
2017         if (!set_file_oplock(fsp, fsp->oplock_type)) {
2018                 /* Could not get the kernel oplock */
2019                 fsp->oplock_type = NO_OPLOCK;
2020         }
2021
2022         if (info == FILE_WAS_OVERWRITTEN || info == FILE_WAS_CREATED || info == FILE_WAS_SUPERSEDED) {
2023                 new_file_created = True;
2024         }
2025
2026         set_share_mode(lck, fsp, conn->server_info->utok.uid, 0,
2027                        fsp->oplock_type);
2028
2029         /* Handle strange delete on close create semantics. */
2030         if (create_options & FILE_DELETE_ON_CLOSE) {
2031
2032                 status = can_set_delete_on_close(fsp, True, new_dos_attributes);
2033
2034                 if (!NT_STATUS_IS_OK(status)) {
2035                         /* Remember to delete the mode we just added. */
2036                         del_share_mode(lck, fsp);
2037                         TALLOC_FREE(lck);
2038                         fd_close(fsp);
2039                         return status;
2040                 }
2041                 /* Note that here we set the *inital* delete on close flag,
2042                    not the regular one. The magic gets handled in close. */
2043                 fsp->initial_delete_on_close = True;
2044         }
2045
2046         if (new_file_created) {
2047                 /* Files should be initially set as archive */
2048                 if (lp_map_archive(SNUM(conn)) ||
2049                     lp_store_dos_attributes(SNUM(conn))) {
2050                         if (!posix_open) {
2051                                 SMB_STRUCT_STAT tmp_sbuf;
2052                                 SET_STAT_INVALID(tmp_sbuf);
2053                                 if (file_set_dosmode(
2054                                             conn, fname,
2055                                             new_dos_attributes | aARCH,
2056                                             &tmp_sbuf, parent_dir,
2057                                             true) == 0) {
2058                                         unx_mode = tmp_sbuf.st_mode;
2059                                 }
2060                         }
2061                 }
2062         }
2063
2064         /*
2065          * Take care of inherited ACLs on created files - if default ACL not
2066          * selected.
2067          */
2068
2069         if (!posix_open && !file_existed && !def_acl) {
2070
2071                 int saved_errno = errno; /* We might get ENOSYS in the next
2072                                           * call.. */
2073
2074                 if (SMB_VFS_FCHMOD_ACL(fsp, unx_mode) == -1 &&
2075                     errno == ENOSYS) {
2076                         errno = saved_errno; /* Ignore ENOSYS */
2077                 }
2078
2079         } else if (new_unx_mode) {
2080
2081                 int ret = -1;
2082
2083                 /* Attributes need changing. File already existed. */
2084
2085                 {
2086                         int saved_errno = errno; /* We might get ENOSYS in the
2087                                                   * next call.. */
2088                         ret = SMB_VFS_FCHMOD_ACL(fsp, new_unx_mode);
2089
2090                         if (ret == -1 && errno == ENOSYS) {
2091                                 errno = saved_errno; /* Ignore ENOSYS */
2092                         } else {
2093                                 DEBUG(5, ("open_file_ntcreate: reset "
2094                                           "attributes of file %s to 0%o\n",
2095                                           fname, (unsigned int)new_unx_mode));
2096                                 ret = 0; /* Don't do the fchmod below. */
2097                         }
2098                 }
2099
2100                 if ((ret == -1) &&
2101                     (SMB_VFS_FCHMOD(fsp, new_unx_mode) == -1))
2102                         DEBUG(5, ("open_file_ntcreate: failed to reset "
2103                                   "attributes of file %s to 0%o\n",
2104                                   fname, (unsigned int)new_unx_mode));
2105         }
2106
2107         /* If this is a successful open, we must remove any deferred open
2108          * records. */
2109         if (req != NULL) {
2110                 del_deferred_open_entry(lck, req->mid);
2111         }
2112         TALLOC_FREE(lck);
2113
2114         return NT_STATUS_OK;
2115 }
2116
2117 /****************************************************************************
2118  Open a file with a share mode.
2119 ****************************************************************************/
2120
2121 NTSTATUS open_file_ntcreate(connection_struct *conn,
2122                             struct smb_request *req,
2123                             const char *fname,
2124                             SMB_STRUCT_STAT *psbuf,
2125                             uint32 access_mask,         /* access bits (FILE_READ_DATA etc.) */
2126                             uint32 share_access,        /* share constants (FILE_SHARE_READ etc) */
2127                             uint32 create_disposition,  /* FILE_OPEN_IF etc. */
2128                             uint32 create_options,      /* options such as delete on close. */
2129                             uint32 new_dos_attributes,  /* attributes used for new file. */
2130                             int oplock_request,         /* internal Samba oplock codes. */
2131                                                         /* Information (FILE_EXISTS etc.) */
2132                             int *pinfo,
2133                             files_struct **result)
2134 {
2135         NTSTATUS status;
2136         files_struct *fsp = NULL;
2137
2138         *result = NULL;
2139
2140         status = file_new(conn, &fsp);
2141         if(!NT_STATUS_IS_OK(status)) {
2142                 return status;
2143         }
2144
2145         status = open_file_ntcreate_internal(conn,
2146                                         req,
2147                                         fname,
2148                                         psbuf,
2149                                         access_mask,
2150                                         share_access,
2151                                         create_disposition,
2152                                         create_options,
2153                                         new_dos_attributes,
2154                                         oplock_request,
2155                                         pinfo,
2156                                         fsp);
2157
2158         if(!NT_STATUS_IS_OK(status)) {
2159                 file_free(fsp);
2160                 return status;
2161         }
2162
2163         *result = fsp;
2164         return status;
2165 }
2166
2167 /****************************************************************************
2168  Open a file for for write to ensure that we can fchmod it.
2169 ****************************************************************************/
2170
2171 NTSTATUS open_file_fchmod(connection_struct *conn, const char *fname,
2172                           SMB_STRUCT_STAT *psbuf, files_struct **result)
2173 {
2174         files_struct *fsp = NULL;
2175         NTSTATUS status;
2176
2177         if (!VALID_STAT(*psbuf)) {
2178                 return NT_STATUS_INVALID_PARAMETER;
2179         }
2180
2181         status = file_new(conn, &fsp);
2182         if(!NT_STATUS_IS_OK(status)) {
2183                 return status;
2184         }
2185
2186         /* note! we must use a non-zero desired access or we don't get
2187            a real file descriptor. Oh what a twisted web we weave. */
2188         status = open_file(fsp, conn, NULL, NULL, NULL, fname, psbuf, O_WRONLY,
2189                            0, FILE_WRITE_DATA, FILE_WRITE_DATA);
2190
2191         /*
2192          * This is not a user visible file open.
2193          * Don't set a share mode.
2194          */
2195
2196         if (!NT_STATUS_IS_OK(status)) {
2197                 file_free(fsp);
2198                 return status;
2199         }
2200
2201         *result = fsp;
2202         return NT_STATUS_OK;
2203 }
2204
2205 /****************************************************************************
2206  Close the fchmod file fd - ensure no locks are lost.
2207 ****************************************************************************/
2208
2209 NTSTATUS close_file_fchmod(files_struct *fsp)
2210 {
2211         NTSTATUS status = fd_close(fsp);
2212         file_free(fsp);
2213         return status;
2214 }
2215
2216 static NTSTATUS mkdir_internal(connection_struct *conn,
2217                                 const char *name,
2218                                 uint32 file_attributes,
2219                                 SMB_STRUCT_STAT *psbuf)
2220 {
2221         mode_t mode;
2222         char *parent_dir;
2223         const char *dirname;
2224         NTSTATUS status;
2225         bool posix_open = false;
2226
2227         if(!CAN_WRITE(conn)) {
2228                 DEBUG(5,("mkdir_internal: failing create on read-only share "
2229                          "%s\n", lp_servicename(SNUM(conn))));
2230                 return NT_STATUS_ACCESS_DENIED;
2231         }
2232
2233         status = check_name(conn, name);
2234         if (!NT_STATUS_IS_OK(status)) {
2235                 return status;
2236         }
2237
2238         if (!parent_dirname_talloc(talloc_tos(), name, &parent_dir,
2239                                    &dirname)) {
2240                 return NT_STATUS_NO_MEMORY;
2241         }
2242
2243         if (file_attributes & FILE_FLAG_POSIX_SEMANTICS) {
2244                 posix_open = true;
2245                 mode = (mode_t)(file_attributes & ~FILE_FLAG_POSIX_SEMANTICS);
2246         } else {
2247                 mode = unix_mode(conn, aDIR, name, parent_dir);
2248         }
2249
2250         if (SMB_VFS_MKDIR(conn, name, mode) != 0) {
2251                 return map_nt_error_from_unix(errno);
2252         }
2253
2254         /* Ensure we're checking for a symlink here.... */
2255         /* We don't want to get caught by a symlink racer. */
2256
2257         if (SMB_VFS_LSTAT(conn, name, psbuf) == -1) {
2258                 DEBUG(2, ("Could not stat directory '%s' just created: %s\n",
2259                           name, strerror(errno)));
2260                 return map_nt_error_from_unix(errno);
2261         }
2262
2263         if (!S_ISDIR(psbuf->st_mode)) {
2264                 DEBUG(0, ("Directory just '%s' created is not a directory\n",
2265                           name));
2266                 return NT_STATUS_ACCESS_DENIED;
2267         }
2268
2269         if (lp_store_dos_attributes(SNUM(conn))) {
2270                 if (!posix_open) {
2271                         file_set_dosmode(conn, name,
2272                                  file_attributes | aDIR, NULL,
2273                                  parent_dir,
2274                                  true);
2275                 }
2276         }
2277
2278         if (lp_inherit_perms(SNUM(conn))) {
2279                 inherit_access_posix_acl(conn, parent_dir, name, mode);
2280         }
2281
2282         if (!(file_attributes & FILE_FLAG_POSIX_SEMANTICS)) {
2283                 /*
2284                  * Check if high bits should have been set,
2285                  * then (if bits are missing): add them.
2286                  * Consider bits automagically set by UNIX, i.e. SGID bit from parent
2287                  * dir.
2288                  */
2289                 if (mode & ~(S_IRWXU|S_IRWXG|S_IRWXO) && (mode & ~psbuf->st_mode)) {
2290                         SMB_VFS_CHMOD(conn, name,
2291                                       psbuf->st_mode | (mode & ~psbuf->st_mode));
2292                 }
2293         }
2294
2295         /* Change the owner if required. */
2296         if (lp_inherit_owner(SNUM(conn))) {
2297                 change_dir_owner_to_parent(conn, parent_dir, name, psbuf);
2298         }
2299
2300         notify_fname(conn, NOTIFY_ACTION_ADDED, FILE_NOTIFY_CHANGE_DIR_NAME,
2301                      name);
2302
2303         return NT_STATUS_OK;
2304 }
2305
2306 /****************************************************************************
2307  Open a directory from an NT SMB call.
2308 ****************************************************************************/
2309
2310 NTSTATUS open_directory(connection_struct *conn,
2311                         struct smb_request *req,
2312                         const char *fname,
2313                         SMB_STRUCT_STAT *psbuf,
2314                         uint32 access_mask,
2315                         uint32 share_access,
2316                         uint32 create_disposition,
2317                         uint32 create_options,
2318                         uint32 file_attributes,
2319                         int *pinfo,
2320                         files_struct **result)
2321 {
2322         files_struct *fsp = NULL;
2323         bool dir_existed = VALID_STAT(*psbuf) ? True : False;
2324         struct share_mode_lock *lck = NULL;
2325         NTSTATUS status;
2326         struct timespec mtimespec;
2327         int info = 0;
2328
2329         DEBUG(5,("open_directory: opening directory %s, access_mask = 0x%x, "
2330                  "share_access = 0x%x create_options = 0x%x, "
2331                  "create_disposition = 0x%x, file_attributes = 0x%x\n",
2332                  fname,
2333                  (unsigned int)access_mask,
2334                  (unsigned int)share_access,
2335                  (unsigned int)create_options,
2336                  (unsigned int)create_disposition,
2337                  (unsigned int)file_attributes));
2338
2339         if (!(file_attributes & FILE_FLAG_POSIX_SEMANTICS) &&
2340                         (conn->fs_capabilities & FILE_NAMED_STREAMS) &&
2341                         is_ntfs_stream_name(fname)) {
2342                 DEBUG(2, ("open_directory: %s is a stream name!\n", fname));
2343                 return NT_STATUS_NOT_A_DIRECTORY;
2344         }
2345
2346         status = calculate_access_mask(conn, fname, dir_existed,
2347                                         access_mask,
2348                                         &access_mask);
2349         if (!NT_STATUS_IS_OK(status)) {
2350                 DEBUG(10, ("open_directory: calculate_access_mask "
2351                         "on file %s returned %s\n",
2352                         fname,
2353                         nt_errstr(status)));
2354                 return status;
2355         }
2356
2357         switch( create_disposition ) {
2358                 case FILE_OPEN:
2359
2360                         info = FILE_WAS_OPENED;
2361
2362                         /*
2363                          * We want to follow symlinks here.
2364                          */
2365
2366                         if (SMB_VFS_STAT(conn, fname, psbuf) != 0) {
2367                                 return map_nt_error_from_unix(errno);
2368                         }
2369
2370                         break;
2371
2372                 case FILE_CREATE:
2373
2374                         /* If directory exists error. If directory doesn't
2375                          * exist create. */
2376
2377                         status = mkdir_internal(conn,
2378                                                 fname,
2379                                                 file_attributes,
2380                                                 psbuf);
2381
2382                         if (!NT_STATUS_IS_OK(status)) {
2383                                 DEBUG(2, ("open_directory: unable to create "
2384                                           "%s. Error was %s\n", fname,
2385                                           nt_errstr(status)));
2386                                 return status;
2387                         }
2388
2389                         info = FILE_WAS_CREATED;
2390                         break;
2391
2392                 case FILE_OPEN_IF:
2393                         /*
2394                          * If directory exists open. If directory doesn't
2395                          * exist create.
2396                          */
2397
2398                         status = mkdir_internal(conn,
2399                                                 fname,
2400                                                 file_attributes,
2401                                                 psbuf);
2402
2403                         if (NT_STATUS_IS_OK(status)) {
2404                                 info = FILE_WAS_CREATED;
2405                         }
2406
2407                         if (NT_STATUS_EQUAL(status,
2408                                             NT_STATUS_OBJECT_NAME_COLLISION)) {
2409                                 info = FILE_WAS_OPENED;
2410                                 status = NT_STATUS_OK;
2411                         }
2412
2413                         break;
2414
2415                 case FILE_SUPERSEDE:
2416                 case FILE_OVERWRITE:
2417                 case FILE_OVERWRITE_IF:
2418                 default:
2419                         DEBUG(5,("open_directory: invalid create_disposition "
2420                                  "0x%x for directory %s\n",
2421                                  (unsigned int)create_disposition, fname));
2422                         return NT_STATUS_INVALID_PARAMETER;
2423         }
2424
2425         if(!S_ISDIR(psbuf->st_mode)) {
2426                 DEBUG(5,("open_directory: %s is not a directory !\n",
2427                          fname ));
2428                 return NT_STATUS_NOT_A_DIRECTORY;
2429         }
2430
2431         if (info == FILE_WAS_OPENED) {
2432                 uint32_t access_granted = 0;
2433                 status = check_open_rights(conn,
2434                                         fname,
2435                                         access_mask,
2436                                         &access_granted);
2437                 if (!NT_STATUS_IS_OK(status)) {
2438                         DEBUG(10, ("open_directory: check_open_rights on "
2439                                 "file  %s failed with %s\n",
2440                                 fname,
2441                                 nt_errstr(status)));
2442                         return status;
2443                 }
2444         }
2445
2446         status = file_new(conn, &fsp);
2447         if(!NT_STATUS_IS_OK(status)) {
2448                 return status;
2449         }
2450
2451         /*
2452          * Setup the files_struct for it.
2453          */
2454
2455         fsp->mode = psbuf->st_mode;
2456         fsp->file_id = vfs_file_id_from_sbuf(conn, psbuf);
2457         fsp->vuid = req ? req->vuid : UID_FIELD_INVALID;
2458         fsp->file_pid = req ? req->smbpid : 0;
2459         fsp->can_lock = False;
2460         fsp->can_read = False;
2461         fsp->can_write = False;
2462
2463         fsp->share_access = share_access;
2464         fsp->fh->private_options = create_options;
2465         /*
2466          * According to Samba4, SEC_FILE_READ_ATTRIBUTE is always granted,
2467          */
2468         fsp->access_mask = access_mask | FILE_READ_ATTRIBUTES;
2469         fsp->print_file = False;
2470         fsp->modified = False;
2471         fsp->oplock_type = NO_OPLOCK;
2472         fsp->sent_oplock_break = NO_BREAK_SENT;
2473         fsp->is_directory = True;
2474         fsp->posix_open = (file_attributes & FILE_FLAG_POSIX_SEMANTICS) ? True : False;
2475
2476         string_set(&fsp->fsp_name,fname);
2477
2478         mtimespec = get_mtimespec(psbuf);
2479
2480         lck = get_share_mode_lock(talloc_tos(), fsp->file_id,
2481                                   conn->connectpath,
2482                                   fname, &mtimespec);
2483
2484         if (lck == NULL) {
2485                 DEBUG(0, ("open_directory: Could not get share mode lock for %s\n", fname));
2486                 file_free(fsp);
2487                 return NT_STATUS_SHARING_VIOLATION;
2488         }
2489
2490         status = open_mode_check(conn, fname, lck,
2491                                 access_mask, share_access,
2492                                 create_options, &dir_existed);
2493
2494         if (!NT_STATUS_IS_OK(status)) {
2495                 TALLOC_FREE(lck);
2496                 file_free(fsp);
2497                 return status;
2498         }
2499
2500         set_share_mode(lck, fsp, conn->server_info->utok.uid, 0, NO_OPLOCK);
2501
2502         /* For directories the delete on close bit at open time seems
2503            always to be honored on close... See test 19 in Samba4 BASE-DELETE. */
2504         if (create_options & FILE_DELETE_ON_CLOSE) {
2505                 status = can_set_delete_on_close(fsp, True, 0);
2506                 if (!NT_STATUS_IS_OK(status) && !NT_STATUS_EQUAL(status, NT_STATUS_DIRECTORY_NOT_EMPTY)) {
2507                         TALLOC_FREE(lck);
2508                         file_free(fsp);
2509                         return status;
2510                 }
2511
2512                 if (NT_STATUS_IS_OK(status)) {
2513                         /* Note that here we set the *inital* delete on close flag,
2514                            not the regular one. The magic gets handled in close. */
2515                         fsp->initial_delete_on_close = True;
2516                 }
2517         }
2518
2519         TALLOC_FREE(lck);
2520
2521         if (pinfo) {
2522                 *pinfo = info;
2523         }
2524
2525         *result = fsp;
2526         return NT_STATUS_OK;
2527 }
2528
2529 NTSTATUS create_directory(connection_struct *conn, struct smb_request *req, const char *directory)
2530 {
2531         NTSTATUS status;
2532         SMB_STRUCT_STAT sbuf;
2533         files_struct *fsp;
2534
2535         SET_STAT_INVALID(sbuf);
2536
2537         status = open_directory(conn, req, directory, &sbuf,
2538                                 FILE_READ_ATTRIBUTES, /* Just a stat open */
2539                                 FILE_SHARE_NONE, /* Ignored for stat opens */
2540                                 FILE_CREATE,
2541                                 0,
2542                                 FILE_ATTRIBUTE_DIRECTORY,
2543                                 NULL,
2544                                 &fsp);
2545
2546         if (NT_STATUS_IS_OK(status)) {
2547                 close_file(fsp, NORMAL_CLOSE);
2548         }
2549
2550         return status;
2551 }
2552
2553 /****************************************************************************
2554  Receive notification that one of our open files has been renamed by another
2555  smbd process.
2556 ****************************************************************************/
2557
2558 void msg_file_was_renamed(struct messaging_context *msg,
2559                           void *private_data,
2560                           uint32_t msg_type,
2561                           struct server_id server_id,
2562                           DATA_BLOB *data)
2563 {
2564         files_struct *fsp;
2565         char *frm = (char *)data->data;
2566         struct file_id id;
2567         const char *sharepath;
2568         const char *newname;
2569         size_t sp_len;
2570
2571         if (data->data == NULL
2572             || data->length < MSG_FILE_RENAMED_MIN_SIZE + 2) {
2573                 DEBUG(0, ("msg_file_was_renamed: Got invalid msg len %d\n",
2574                           (int)data->length));
2575                 return;
2576         }
2577
2578         /* Unpack the message. */
2579         pull_file_id_16(frm, &id);
2580         sharepath = &frm[16];
2581         newname = sharepath + strlen(sharepath) + 1;
2582         sp_len = strlen(sharepath);
2583
2584         DEBUG(10,("msg_file_was_renamed: Got rename message for sharepath %s, new name %s, "
2585                 "file_id %s\n",
2586                   sharepath, newname, file_id_string_tos(&id)));
2587
2588         for(fsp = file_find_di_first(id); fsp; fsp = file_find_di_next(fsp)) {
2589                 if (memcmp(fsp->conn->connectpath, sharepath, sp_len) == 0) {
2590                         DEBUG(10,("msg_file_was_renamed: renaming file fnum %d from %s -> %s\n",
2591                                 fsp->fnum, fsp->fsp_name, newname ));
2592                         string_set(&fsp->fsp_name, newname);
2593                 } else {
2594                         /* TODO. JRA. */
2595                         /* Now we have the complete path we can work out if this is
2596                            actually within this share and adjust newname accordingly. */
2597                         DEBUG(10,("msg_file_was_renamed: share mismatch (sharepath %s "
2598                                 "not sharepath %s) "
2599                                 "fnum %d from %s -> %s\n",
2600                                 fsp->conn->connectpath,
2601                                 sharepath,
2602                                 fsp->fnum,
2603                                 fsp->fsp_name,
2604                                 newname ));
2605                 }
2606         }
2607 }
2608
2609 struct case_semantics_state {
2610         connection_struct *conn;
2611         bool case_sensitive;
2612         bool case_preserve;
2613         bool short_case_preserve;
2614 };
2615
2616 /****************************************************************************
2617  Restore case semantics.
2618 ****************************************************************************/
2619 static int restore_case_semantics(struct case_semantics_state *state)
2620 {
2621         state->conn->case_sensitive = state->case_sensitive;
2622         state->conn->case_preserve = state->case_preserve;
2623         state->conn->short_case_preserve = state->short_case_preserve;
2624         return 0;
2625 }
2626
2627 /****************************************************************************
2628  Save case semantics.
2629 ****************************************************************************/
2630 static struct case_semantics_state *set_posix_case_semantics(TALLOC_CTX *mem_ctx,
2631                                                              connection_struct *conn)
2632 {
2633         struct case_semantics_state *result;
2634
2635         if (!(result = talloc(mem_ctx, struct case_semantics_state))) {
2636                 DEBUG(0, ("talloc failed\n"));
2637                 return NULL;
2638         }
2639
2640         result->conn = conn;
2641         result->case_sensitive = conn->case_sensitive;
2642         result->case_preserve = conn->case_preserve;
2643         result->short_case_preserve = conn->short_case_preserve;
2644
2645         /* Set to POSIX. */
2646         conn->case_sensitive = True;
2647         conn->case_preserve = True;
2648         conn->short_case_preserve = True;
2649
2650         talloc_set_destructor(result, restore_case_semantics);
2651
2652         return result;
2653 }
2654
2655 /*
2656  * If a main file is opened for delete, all streams need to be checked for
2657  * !FILE_SHARE_DELETE. Do this by opening with DELETE_ACCESS.
2658  * If that works, delete them all by setting the delete on close and close.
2659  */
2660
2661 static NTSTATUS open_streams_for_delete(connection_struct *conn,
2662                                         const char *fname)
2663 {
2664         struct stream_struct *stream_info;
2665         files_struct **streams;
2666         int i;
2667         unsigned int num_streams;
2668         TALLOC_CTX *frame = talloc_stackframe();
2669         NTSTATUS status;
2670
2671         status = SMB_VFS_STREAMINFO(conn, NULL, fname, talloc_tos(),
2672                                     &num_streams, &stream_info);
2673
2674         if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_IMPLEMENTED)
2675             || NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
2676                 DEBUG(10, ("no streams around\n"));
2677                 TALLOC_FREE(frame);
2678                 return NT_STATUS_OK;
2679         }
2680
2681         if (!NT_STATUS_IS_OK(status)) {
2682                 DEBUG(10, ("SMB_VFS_STREAMINFO failed: %s\n",
2683                            nt_errstr(status)));
2684                 goto fail;
2685         }
2686
2687         DEBUG(10, ("open_streams_for_delete found %d streams\n",
2688                    num_streams));
2689
2690         if (num_streams == 0) {
2691                 TALLOC_FREE(frame);
2692                 return NT_STATUS_OK;
2693         }
2694
2695         streams = TALLOC_ARRAY(talloc_tos(), files_struct *, num_streams);
2696         if (streams == NULL) {
2697                 DEBUG(0, ("talloc failed\n"));
2698                 status = NT_STATUS_NO_MEMORY;
2699                 goto fail;
2700         }
2701
2702         for (i=0; i<num_streams; i++) {
2703                 char *streamname;
2704
2705                 if (strequal(stream_info[i].name, "::$DATA")) {
2706                         streams[i] = NULL;
2707                         continue;
2708                 }
2709
2710                 streamname = talloc_asprintf(talloc_tos(), "%s%s", fname,
2711                                              stream_info[i].name);
2712
2713                 if (streamname == NULL) {
2714                         DEBUG(0, ("talloc_aprintf failed\n"));
2715                         status = NT_STATUS_NO_MEMORY;
2716                         goto fail;
2717                 }
2718
2719                 status = create_file_unixpath
2720                         (conn,                  /* conn */
2721                          NULL,                  /* req */
2722                          streamname,            /* fname */
2723                          DELETE_ACCESS,         /* access_mask */
2724                          FILE_SHARE_READ | FILE_SHARE_WRITE
2725                          | FILE_SHARE_DELETE,   /* share_access */
2726                          FILE_OPEN,             /* create_disposition*/
2727                          NTCREATEX_OPTIONS_PRIVATE_STREAM_DELETE, /* create_options */
2728                          FILE_ATTRIBUTE_NORMAL, /* file_attributes */
2729                          0,                     /* oplock_request */
2730                          0,                     /* allocation_size */
2731                          NULL,                  /* sd */
2732                          NULL,                  /* ea_list */
2733                          &streams[i],           /* result */
2734                          NULL,                  /* pinfo */
2735                          NULL);                 /* psbuf */
2736
2737                 TALLOC_FREE(streamname);
2738
2739                 if (!NT_STATUS_IS_OK(status)) {
2740                         DEBUG(10, ("Could not open stream %s: %s\n",
2741                                    streamname, nt_errstr(status)));
2742                         break;
2743                 }
2744         }
2745
2746         /*
2747          * don't touch the variable "status" beyond this point :-)
2748          */
2749
2750         for (i -= 1 ; i >= 0; i--) {
2751                 if (streams[i] == NULL) {
2752                         continue;
2753                 }
2754
2755                 DEBUG(10, ("Closing stream # %d, %s\n", i,
2756                            streams[i]->fsp_name));
2757                 close_file(streams[i], NORMAL_CLOSE);
2758         }
2759
2760  fail:
2761         TALLOC_FREE(frame);
2762         return status;
2763 }
2764
2765 /*
2766  * Wrapper around open_file_ntcreate and open_directory
2767  */
2768
2769 NTSTATUS create_file_unixpath(connection_struct *conn,
2770                               struct smb_request *req,
2771                               const char *fname,
2772                               uint32_t access_mask,
2773                               uint32_t share_access,
2774                               uint32_t create_disposition,
2775                               uint32_t create_options,
2776                               uint32_t file_attributes,
2777                               uint32_t oplock_request,
2778                               SMB_BIG_UINT allocation_size,
2779                               struct security_descriptor *sd,
2780                               struct ea_list *ea_list,
2781
2782                               files_struct **result,
2783                               int *pinfo,
2784                               SMB_STRUCT_STAT *psbuf)
2785 {
2786         SMB_STRUCT_STAT sbuf;
2787         int info = FILE_WAS_OPENED;
2788         files_struct *base_fsp = NULL;
2789         files_struct *fsp = NULL;
2790         NTSTATUS status;
2791
2792         DEBUG(10,("create_file_unixpath: access_mask = 0x%x "
2793                   "file_attributes = 0x%x, share_access = 0x%x, "
2794                   "create_disposition = 0x%x create_options = 0x%x "
2795                   "oplock_request = 0x%x ea_list = 0x%p, sd = 0x%p, "
2796                   "fname = %s\n",
2797                   (unsigned int)access_mask,
2798                   (unsigned int)file_attributes,
2799                   (unsigned int)share_access,
2800                   (unsigned int)create_disposition,
2801                   (unsigned int)create_options,
2802                   (unsigned int)oplock_request,
2803                   ea_list, sd, fname));
2804
2805         if (create_options & FILE_OPEN_BY_FILE_ID) {
2806                 status = NT_STATUS_NOT_SUPPORTED;
2807                 goto fail;
2808         }
2809
2810         if (create_options & NTCREATEX_OPTIONS_INVALID_PARAM_MASK) {
2811                 status = NT_STATUS_INVALID_PARAMETER;
2812                 goto fail;
2813         }
2814
2815         if (req == NULL) {
2816                 oplock_request |= INTERNAL_OPEN_ONLY;
2817         }
2818
2819         if (psbuf != NULL) {
2820                 sbuf = *psbuf;
2821         }
2822         else {
2823                 if (SMB_VFS_STAT(conn, fname, &sbuf) == -1) {
2824                         SET_STAT_INVALID(sbuf);
2825                 }
2826         }
2827
2828         if ((conn->fs_capabilities & FILE_NAMED_STREAMS)
2829             && (access_mask & DELETE_ACCESS)
2830             && !is_ntfs_stream_name(fname)) {
2831                 /*
2832                  * We can't open a file with DELETE access if any of the
2833                  * streams is open without FILE_SHARE_DELETE
2834                  */
2835                 status = open_streams_for_delete(conn, fname);
2836
2837                 if (!NT_STATUS_IS_OK(status)) {
2838                         goto fail;
2839                 }
2840         }
2841
2842         /* This is the correct thing to do (check every time) but can_delete
2843          * is expensive (it may have to read the parent directory
2844          * permissions). So for now we're not doing it unless we have a strong
2845          * hint the client is really going to delete this file. If the client
2846          * is forcing FILE_CREATE let the filesystem take care of the
2847          * permissions. */
2848
2849         /* Setting FILE_SHARE_DELETE is the hint. */
2850
2851         if (lp_acl_check_permissions(SNUM(conn))
2852             && (create_disposition != FILE_CREATE)
2853             && (share_access & FILE_SHARE_DELETE)
2854             && (access_mask & DELETE_ACCESS)
2855             && (!(can_delete_file_in_directory(conn, fname) ||
2856                  can_access_file_acl(conn, fname, DELETE_ACCESS)))) {
2857                 status = NT_STATUS_ACCESS_DENIED;
2858                 DEBUG(10,("create_file_unixpath: open file %s "
2859                         "for delete ACCESS_DENIED\n", fname ));
2860                 goto fail;
2861         }
2862
2863 #if 0
2864         /* We need to support SeSecurityPrivilege for this. */
2865         if ((access_mask & SEC_RIGHT_SYSTEM_SECURITY) &&
2866             !user_has_privileges(current_user.nt_user_token,
2867                                  &se_security)) {
2868                 status = NT_STATUS_PRIVILEGE_NOT_HELD;
2869                 goto fail;
2870         }
2871 #endif
2872
2873         if ((conn->fs_capabilities & FILE_NAMED_STREAMS)
2874             && is_ntfs_stream_name(fname)
2875             && (!(create_options & NTCREATEX_OPTIONS_PRIVATE_STREAM_DELETE))) {
2876                 char *base;
2877                 uint32 base_create_disposition;
2878
2879                 if (create_options & FILE_DIRECTORY_FILE) {
2880                         status = NT_STATUS_NOT_A_DIRECTORY;
2881                         goto fail;
2882                 }
2883
2884                 status = split_ntfs_stream_name(talloc_tos(), fname,
2885                                                 &base, NULL);
2886                 if (!NT_STATUS_IS_OK(status)) {
2887                         DEBUG(10, ("create_file_unixpath: "
2888                                 "split_ntfs_stream_name failed: %s\n",
2889                                 nt_errstr(status)));
2890                         goto fail;
2891                 }
2892
2893                 SMB_ASSERT(!is_ntfs_stream_name(base)); /* paranoia.. */
2894
2895                 switch (create_disposition) {
2896                 case FILE_OPEN:
2897                         base_create_disposition = FILE_OPEN;
2898                         break;
2899                 default:
2900                         base_create_disposition = FILE_OPEN_IF;
2901                         break;
2902                 }
2903
2904                 status = create_file_unixpath(conn, NULL, base, 0,
2905                                               FILE_SHARE_READ
2906                                               | FILE_SHARE_WRITE
2907                                               | FILE_SHARE_DELETE,
2908                                               base_create_disposition,
2909                                               0, 0, 0, 0, NULL, NULL,
2910                                               &base_fsp, NULL, NULL);
2911                 if (!NT_STATUS_IS_OK(status)) {
2912                         DEBUG(10, ("create_file_unixpath for base %s failed: "
2913                                    "%s\n", base, nt_errstr(status)));
2914                         goto fail;
2915                 }
2916                 /* we don't need to low level fd */
2917                 fd_close(base_fsp);
2918         }
2919
2920         /*
2921          * If it's a request for a directory open, deal with it separately.
2922          */
2923
2924         if (create_options & FILE_DIRECTORY_FILE) {
2925
2926                 if (create_options & FILE_NON_DIRECTORY_FILE) {
2927                         status = NT_STATUS_INVALID_PARAMETER;
2928                         goto fail;
2929                 }
2930
2931                 /* Can't open a temp directory. IFS kit test. */
2932                 if (file_attributes & FILE_ATTRIBUTE_TEMPORARY) {
2933                         status = NT_STATUS_INVALID_PARAMETER;
2934                         goto fail;
2935                 }
2936
2937                 /*
2938                  * We will get a create directory here if the Win32
2939                  * app specified a security descriptor in the
2940                  * CreateDirectory() call.
2941                  */
2942
2943                 oplock_request = 0;
2944                 status = open_directory(
2945                         conn, req, fname, &sbuf, access_mask, share_access,
2946                         create_disposition, create_options, file_attributes,
2947                         &info, &fsp);
2948         } else {
2949
2950                 /*
2951                  * Ordinary file case.
2952                  */
2953
2954                 if (base_fsp) {
2955                         /*
2956                          * We're opening the stream element of a base_fsp
2957                          * we already opened. We need to initialize
2958                          * the fsp first, and set up the base_fsp pointer.
2959                          */
2960                         status = file_new(conn, &fsp);
2961                         if(!NT_STATUS_IS_OK(status)) {
2962                                 goto fail;
2963                         }
2964
2965                         fsp->base_fsp = base_fsp;
2966
2967                         status = open_file_ntcreate_internal(conn,
2968                                                 req,
2969                                                 fname,
2970                                                 &sbuf,
2971                                                 access_mask,
2972                                                 share_access,
2973                                                 create_disposition,
2974                                                 create_options,
2975                                                 file_attributes,
2976                                                 oplock_request,
2977                                                 &info,
2978                                                 fsp);
2979
2980                         if(!NT_STATUS_IS_OK(status)) {
2981                                 file_free(fsp);
2982                                 fsp = NULL;
2983                         }
2984                 } else {
2985                         status = open_file_ntcreate(
2986                                 conn, req, fname, &sbuf, access_mask, share_access,
2987                                 create_disposition, create_options, file_attributes,
2988                                 oplock_request, &info, &fsp);
2989                 }
2990
2991                 if (NT_STATUS_EQUAL(status, NT_STATUS_FILE_IS_A_DIRECTORY)) {
2992
2993                         /* A stream open never opens a directory */
2994
2995                         if (base_fsp) {
2996                                 status = NT_STATUS_FILE_IS_A_DIRECTORY;
2997                                 goto fail;
2998                         }
2999
3000                         /*
3001                          * Fail the open if it was explicitly a non-directory
3002                          * file.
3003                          */
3004
3005                         if (create_options & FILE_NON_DIRECTORY_FILE) {
3006                                 status = NT_STATUS_FILE_IS_A_DIRECTORY;
3007                                 goto fail;
3008                         }
3009
3010                         oplock_request = 0;
3011                         status = open_directory(
3012                                 conn, req, fname, &sbuf, access_mask,
3013                                 share_access, create_disposition,
3014                                 create_options, file_attributes,
3015                                 &info, &fsp);
3016                 }
3017         }
3018
3019         if (!NT_STATUS_IS_OK(status)) {
3020                 goto fail;
3021         }
3022
3023         fsp->base_fsp = base_fsp;
3024
3025         /*
3026          * According to the MS documentation, the only time the security
3027          * descriptor is applied to the opened file is iff we *created* the
3028          * file; an existing file stays the same.
3029          *
3030          * Also, it seems (from observation) that you can open the file with
3031          * any access mask but you can still write the sd. We need to override
3032          * the granted access before we call set_sd
3033          * Patch for bug #2242 from Tom Lackemann <cessnatomny@yahoo.com>.
3034          */
3035
3036         if ((sd != NULL) && (info == FILE_WAS_CREATED)
3037             && lp_nt_acl_support(SNUM(conn))) {
3038
3039                 uint32_t sec_info_sent = ALL_SECURITY_INFORMATION;
3040                 uint32_t saved_access_mask = fsp->access_mask;
3041
3042                 if (sd->owner_sid == NULL) {
3043                         sec_info_sent &= ~OWNER_SECURITY_INFORMATION;
3044                 }
3045                 if (sd->group_sid == NULL) {
3046                         sec_info_sent &= ~GROUP_SECURITY_INFORMATION;
3047                 }
3048                 if (sd->sacl == NULL) {
3049                         sec_info_sent &= ~SACL_SECURITY_INFORMATION;
3050                 }
3051                 if (sd->dacl == NULL) {
3052                         sec_info_sent &= ~DACL_SECURITY_INFORMATION;
3053                 }
3054
3055                 fsp->access_mask = FILE_GENERIC_ALL;
3056
3057                 /* Convert all the generic bits. */
3058                 security_acl_map_generic(sd->dacl, &file_generic_mapping);
3059                 security_acl_map_generic(sd->sacl, &file_generic_mapping);
3060
3061                 if (sec_info_sent & (OWNER_SECURITY_INFORMATION|
3062                                         GROUP_SECURITY_INFORMATION|
3063                                         DACL_SECURITY_INFORMATION|
3064                                         SACL_SECURITY_INFORMATION)) {
3065                         status = SMB_VFS_FSET_NT_ACL(fsp, sec_info_sent, sd);
3066                 }
3067
3068                 fsp->access_mask = saved_access_mask;
3069
3070                 if (!NT_STATUS_IS_OK(status)) {
3071                         goto fail;
3072                 }
3073         }
3074
3075         if ((ea_list != NULL) && (info == FILE_WAS_CREATED)) {
3076                 status = set_ea(conn, fsp, fname, ea_list);
3077                 if (!NT_STATUS_IS_OK(status)) {
3078                         goto fail;
3079                 }
3080         }
3081
3082         if (!fsp->is_directory && S_ISDIR(sbuf.st_mode)) {
3083                 status = NT_STATUS_ACCESS_DENIED;
3084                 goto fail;
3085         }
3086
3087         /* Save the requested allocation size. */
3088         if ((info == FILE_WAS_CREATED) || (info == FILE_WAS_OVERWRITTEN)) {
3089                 if (allocation_size
3090                     && (allocation_size > sbuf.st_size)) {
3091                         fsp->initial_allocation_size = smb_roundup(
3092                                 fsp->conn, allocation_size);
3093                         if (fsp->is_directory) {
3094                                 /* Can't set allocation size on a directory. */
3095                                 status = NT_STATUS_ACCESS_DENIED;
3096                                 goto fail;
3097                         }
3098                         if (vfs_allocate_file_space(
3099                                     fsp, fsp->initial_allocation_size) == -1) {
3100                                 status = NT_STATUS_DISK_FULL;
3101                                 goto fail;
3102                         }
3103                 } else {
3104                         fsp->initial_allocation_size = smb_roundup(
3105                                 fsp->conn, (SMB_BIG_UINT)sbuf.st_size);
3106                 }
3107         }
3108
3109         DEBUG(10, ("create_file_unixpath: info=%d\n", info));
3110
3111         *result = fsp;
3112         if (pinfo != NULL) {
3113                 *pinfo = info;
3114         }
3115         if (psbuf != NULL) {
3116                 if ((fsp->fh == NULL) || (fsp->fh->fd == -1)) {
3117                         *psbuf = sbuf;
3118                 }
3119                 else {
3120                         SMB_VFS_FSTAT(fsp, psbuf);
3121                 }
3122         }
3123         return NT_STATUS_OK;
3124
3125  fail:
3126         DEBUG(10, ("create_file_unixpath: %s\n", nt_errstr(status)));
3127
3128         if (fsp != NULL) {
3129                 if (base_fsp && fsp->base_fsp == base_fsp) {
3130                         /*
3131                          * The close_file below will close
3132                          * fsp->base_fsp.
3133                          */
3134                         base_fsp = NULL;
3135                 }
3136                 close_file(fsp, ERROR_CLOSE);
3137                 fsp = NULL;
3138         }
3139         if (base_fsp != NULL) {
3140                 close_file(base_fsp, ERROR_CLOSE);
3141                 base_fsp = NULL;
3142         }
3143         return status;
3144 }
3145
3146 NTSTATUS create_file(connection_struct *conn,
3147                      struct smb_request *req,
3148                      uint16_t root_dir_fid,
3149                      const char *fname,
3150                      uint32_t access_mask,
3151                      uint32_t share_access,
3152                      uint32_t create_disposition,
3153                      uint32_t create_options,
3154                      uint32_t file_attributes,
3155                      uint32_t oplock_request,
3156                      SMB_BIG_UINT allocation_size,
3157                      struct security_descriptor *sd,
3158                      struct ea_list *ea_list,
3159
3160                      files_struct **result,
3161                      int *pinfo,
3162                      SMB_STRUCT_STAT *psbuf)
3163 {
3164         struct case_semantics_state *case_state = NULL;
3165         SMB_STRUCT_STAT sbuf;
3166         int info = FILE_WAS_OPENED;
3167         files_struct *fsp = NULL;
3168         NTSTATUS status;
3169
3170         DEBUG(10,("create_file: access_mask = 0x%x "
3171                   "file_attributes = 0x%x, share_access = 0x%x, "
3172                   "create_disposition = 0x%x create_options = 0x%x "
3173                   "oplock_request = 0x%x "
3174                   "root_dir_fid = 0x%x, ea_list = 0x%p, sd = 0x%p, "
3175                   "fname = %s\n",
3176                   (unsigned int)access_mask,
3177                   (unsigned int)file_attributes,
3178                   (unsigned int)share_access,
3179                   (unsigned int)create_disposition,
3180                   (unsigned int)create_options,
3181                   (unsigned int)oplock_request,
3182                   (unsigned int)root_dir_fid,
3183                   ea_list, sd, fname));
3184
3185         /*
3186          * Get the file name.
3187          */
3188
3189         if (root_dir_fid != 0) {
3190                 /*
3191                  * This filename is relative to a directory fid.
3192                  */
3193                 char *parent_fname = NULL;
3194                 files_struct *dir_fsp = file_fsp(root_dir_fid);
3195
3196                 if (dir_fsp == NULL) {
3197                         status = NT_STATUS_INVALID_HANDLE;
3198                         goto fail;
3199                 }
3200
3201                 if (!dir_fsp->is_directory) {
3202
3203                         /*
3204                          * Check to see if this is a mac fork of some kind.
3205                          */
3206
3207                         if ((conn->fs_capabilities & FILE_NAMED_STREAMS) &&
3208                                         is_ntfs_stream_name(fname)) {
3209                                 status = NT_STATUS_OBJECT_PATH_NOT_FOUND;
3210                                 goto fail;
3211                         }
3212
3213                         /*
3214                           we need to handle the case when we get a
3215                           relative open relative to a file and the
3216                           pathname is blank - this is a reopen!
3217                           (hint from demyn plantenberg)
3218                         */
3219
3220                         status = NT_STATUS_INVALID_HANDLE;
3221                         goto fail;
3222                 }
3223
3224                 if (ISDOT(dir_fsp->fsp_name)) {
3225                         /*
3226                          * We're at the toplevel dir, the final file name
3227                          * must not contain ./, as this is filtered out
3228                          * normally by srvstr_get_path and unix_convert
3229                          * explicitly rejects paths containing ./.
3230                          */
3231                         parent_fname = talloc_strdup(talloc_tos(), "");
3232                         if (parent_fname == NULL) {
3233                                 status = NT_STATUS_NO_MEMORY;
3234                                 goto fail;
3235                         }
3236                 } else {
3237                         size_t dir_name_len = strlen(dir_fsp->fsp_name);
3238
3239                         /*
3240                          * Copy in the base directory name.
3241                          */
3242
3243                         parent_fname = TALLOC_ARRAY(talloc_tos(), char,
3244                                                     dir_name_len+2);
3245                         if (parent_fname == NULL) {
3246                                 status = NT_STATUS_NO_MEMORY;
3247                                 goto fail;
3248                         }
3249                         memcpy(parent_fname, dir_fsp->fsp_name,
3250                                dir_name_len+1);
3251
3252                         /*
3253                          * Ensure it ends in a '/'.
3254                          * We used TALLOC_SIZE +2 to add space for the '/'.
3255                          */
3256
3257                         if(dir_name_len
3258                            && (parent_fname[dir_name_len-1] != '\\')
3259                            && (parent_fname[dir_name_len-1] != '/')) {
3260                                 parent_fname[dir_name_len] = '/';
3261                                 parent_fname[dir_name_len+1] = '\0';
3262                         }
3263                 }
3264
3265                 fname = talloc_asprintf(talloc_tos(), "%s%s", parent_fname,
3266                                         fname);
3267                 if (fname == NULL) {
3268                         status = NT_STATUS_NO_MEMORY;
3269                         goto fail;
3270                 }
3271         }
3272
3273         /*
3274          * Check to see if this is a mac fork of some kind.
3275          */
3276
3277         if (is_ntfs_stream_name(fname)) {
3278                 enum FAKE_FILE_TYPE fake_file_type;
3279
3280                 fake_file_type = is_fake_file(fname);
3281
3282                 if (fake_file_type != FAKE_FILE_TYPE_NONE) {
3283
3284                         /*
3285                          * Here we go! support for changing the disk quotas
3286                          * --metze
3287                          *
3288                          * We need to fake up to open this MAGIC QUOTA file
3289                          * and return a valid FID.
3290                          *
3291                          * w2k close this file directly after openening xp
3292                          * also tries a QUERY_FILE_INFO on the file and then
3293                          * close it
3294                          */
3295                         status = open_fake_file(conn, req->vuid,
3296                                                 fake_file_type, fname,
3297                                                 access_mask, &fsp);
3298                         if (!NT_STATUS_IS_OK(status)) {
3299                                 goto fail;
3300                         }
3301
3302                         ZERO_STRUCT(sbuf);
3303                         goto done;
3304                 }
3305
3306                 if (!(conn->fs_capabilities & FILE_NAMED_STREAMS)) {
3307                         status = NT_STATUS_OBJECT_PATH_NOT_FOUND;
3308                         goto fail;
3309                 }
3310         }
3311
3312         if ((req != NULL) && (req->flags2 & FLAGS2_DFS_PATHNAMES)) {
3313                 char *resolved_fname;
3314
3315                 status = resolve_dfspath(talloc_tos(), conn, true, fname,
3316                                          &resolved_fname);
3317
3318                 if (!NT_STATUS_IS_OK(status)) {
3319                         /*
3320                          * For PATH_NOT_COVERED we had
3321                          * reply_botherror(req, NT_STATUS_PATH_NOT_COVERED,
3322                          *                 ERRSRV, ERRbadpath);
3323                          * Need to fix in callers
3324                          */
3325                         goto fail;
3326                 }
3327                 fname = resolved_fname;
3328         }
3329
3330         /*
3331          * Check if POSIX semantics are wanted.
3332          */
3333
3334         if (file_attributes & FILE_FLAG_POSIX_SEMANTICS) {
3335                 case_state = set_posix_case_semantics(talloc_tos(), conn);
3336                 file_attributes &= ~FILE_FLAG_POSIX_SEMANTICS;
3337         }
3338
3339         {
3340                 char *converted_fname;
3341
3342                 SET_STAT_INVALID(sbuf);
3343
3344                 status = unix_convert(talloc_tos(), conn, fname, False,
3345                                       &converted_fname, NULL, &sbuf);
3346                 if (!NT_STATUS_IS_OK(status)) {
3347                         goto fail;
3348                 }
3349                 fname = converted_fname;
3350         }
3351
3352         TALLOC_FREE(case_state);
3353
3354         /* All file access must go through check_name() */
3355
3356         status = check_name(conn, fname);
3357         if (!NT_STATUS_IS_OK(status)) {
3358                 goto fail;
3359         }
3360
3361         status = create_file_unixpath(
3362                 conn, req, fname, access_mask, share_access,
3363                 create_disposition, create_options, file_attributes,
3364                 oplock_request, allocation_size, sd, ea_list,
3365                 &fsp, &info, &sbuf);
3366
3367         if (!NT_STATUS_IS_OK(status)) {
3368                 goto fail;
3369         }
3370
3371  done:
3372         DEBUG(10, ("create_file: info=%d\n", info));
3373
3374         *result = fsp;
3375         if (pinfo != NULL) {
3376                 *pinfo = info;
3377         }
3378         if (psbuf != NULL) {
3379                 *psbuf = sbuf;
3380         }
3381         return NT_STATUS_OK;
3382
3383  fail:
3384         DEBUG(10, ("create_file: %s\n", nt_errstr(status)));
3385
3386         if (fsp != NULL) {
3387                 close_file(fsp, ERROR_CLOSE);
3388                 fsp = NULL;
3389         }
3390         return status;
3391 }