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