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 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(struct connection_struct *conn, 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(conn, 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, fsp->fh->fd, 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 void 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         pstring saved_dir;
 126         SMB_STRUCT_STAT sbuf;
 127         SMB_STRUCT_STAT parent_st;
 128         int ret;
 129
 130         ret = SMB_VFS_STAT(conn, inherit_from_dir, &parent_st);
 131         if (ret == -1) {
 132                 DEBUG(0,("change_dir_owner_to_parent: failed to stat parent "
 133                          "directory %s. Error was %s\n",
 134                          inherit_from_dir, strerror(errno) ));
 135                 return;
 136         }
 137
 138         /* We've already done an lstat into psbuf, and we know it's a
 139            directory. If we can cd into the directory and the dev/ino
 140            are the same then we can safely chown without races as
 141            we're locking the directory in place by being in it.  This
 142            should work on any UNIX (thanks tridge :-). JRA.
 143         */
 144
 145         if (!vfs_GetWd(conn,saved_dir)) {
 146                 DEBUG(0,("change_dir_owner_to_parent: failed to get "
 147                          "current working directory\n"));
 148                 return;
 149         }
 150
 151         /* Chdir into the new path. */
 152         if (vfs_ChDir(conn, fname) == -1) {
 153                 DEBUG(0,("change_dir_owner_to_parent: failed to change "
 154                          "current working directory to %s. Error "
 155                          "was %s\n", fname, strerror(errno) ));
 156                 goto out;
 157         }
 158
 159         if (SMB_VFS_STAT(conn,".",&sbuf) == -1) {
 160                 DEBUG(0,("change_dir_owner_to_parent: failed to stat "
 161                          "directory '.' (%s) Error was %s\n",
 162                          fname, strerror(errno)));
 163                 goto out;
 164         }
 165
 166         /* Ensure we're pointing at the same place. */
 167         if (sbuf.st_dev != psbuf->st_dev ||
 168             sbuf.st_ino != psbuf->st_ino ||
 169             sbuf.st_mode != psbuf->st_mode ) {
 170                 DEBUG(0,("change_dir_owner_to_parent: "
 171                          "device/inode/mode on directory %s changed. "
 172                          "Refusing to chown !\n", fname ));
 173                 goto out;
 174         }
 175
 176         become_root();
 177         ret = SMB_VFS_CHOWN(conn, ".", parent_st.st_uid, (gid_t)-1);
 178         unbecome_root();
 179         if (ret == -1) {
 180                 DEBUG(10,("change_dir_owner_to_parent: failed to chown "
 181                           "directory %s to parent directory uid %u. "
 182                           "Error was %s\n", fname,
 183                           (unsigned int)parent_st.st_uid, strerror(errno) ));
 184                 goto out;
 185         }
 186
 187         DEBUG(10,("change_dir_owner_to_parent: changed ownership of new "
 188                   "directory %s to parent directory uid %u.\n",
 189                   fname, (unsigned int)parent_st.st_uid ));
 190
 191  out:
 192
 193         vfs_ChDir(conn,saved_dir);
 194 }
 195
 196 /****************************************************************************
 197  Open a file.
 198 ****************************************************************************/
 199
 200 static NTSTATUS open_file(files_struct *fsp,
 201                           connection_struct *conn,
 202                           struct smb_request *req,
 203                           const char *parent_dir,
 204                           const char *name,
 205                           const char *path,
 206                           SMB_STRUCT_STAT *psbuf,
 207                           int flags,
 208                           mode_t unx_mode,
 209                           uint32 access_mask, /* client requested access mask. */
 210                           uint32 open_access_mask) /* what we're actually using in the open. */
 211 {
 212         NTSTATUS status = NT_STATUS_OK;
 213         int accmode = (flags & O_ACCMODE);
 214         int local_flags = flags;
 215         BOOL file_existed = VALID_STAT(*psbuf);
 216
 217         fsp->fh->fd = -1;
 218         errno = EPERM;
 219
 220         /* Check permissions */
 221
 222         /*
 223          * This code was changed after seeing a client open request
 224          * containing the open mode of (DENY_WRITE/read-only) with
 225          * the 'create if not exist' bit set. The previous code
 226          * would fail to open the file read only on a read-only share
 227          * as it was checking the flags parameter  directly against O_RDONLY,
 228          * this was failing as the flags parameter was set to O_RDONLY|O_CREAT.
 229          * JRA.
 230          */
 231
 232         if (!CAN_WRITE(conn)) {
 233                 /* It's a read-only share - fail if we wanted to write. */
 234                 if(accmode != O_RDONLY) {
 235                         DEBUG(3,("Permission denied opening %s\n", path));
 236                         return NT_STATUS_ACCESS_DENIED;
 237                 } else if(flags & O_CREAT) {
 238                         /* We don't want to write - but we must make sure that
 239                            O_CREAT doesn't create the file if we have write
 240                            access into the directory.
 241                         */
 242                         flags &= ~O_CREAT;
 243                         local_flags &= ~O_CREAT;
 244                 }
 245         }
 246
 247         /*
 248          * This little piece of insanity is inspired by the
 249          * fact that an NT client can open a file for O_RDONLY,
 250          * but set the create disposition to FILE_EXISTS_TRUNCATE.
 251          * If the client *can* write to the file, then it expects to
 252          * truncate the file, even though it is opening for readonly.
 253          * Quicken uses this stupid trick in backup file creation...
 254          * Thanks *greatly* to "David W. Chapman Jr." <dwcjr@inethouston.net>
 255          * for helping track this one down. It didn't bite us in 2.0.x
 256          * as we always opened files read-write in that release. JRA.
 257          */
 258
 259         if ((accmode == O_RDONLY) && ((flags & O_TRUNC) == O_TRUNC)) {
 260                 DEBUG(10,("open_file: truncate requested on read-only open "
 261                           "for file %s\n", path));
 262                 local_flags = (flags & ~O_ACCMODE)|O_RDWR;
 263         }
 264
 265         if ((open_access_mask & (FILE_READ_DATA|FILE_WRITE_DATA|FILE_APPEND_DATA|FILE_EXECUTE)) ||
 266             (!file_existed && (local_flags & O_CREAT)) ||
 267             ((local_flags & O_TRUNC) == O_TRUNC) ) {
 268
 269                 /*
 270                  * We can't actually truncate here as the file may be locked.
 271                  * open_file_ntcreate will take care of the truncate later. JRA.
 272                  */
 273
 274                 local_flags &= ~O_TRUNC;
 275
 276 #if defined(O_NONBLOCK) && defined(S_ISFIFO)
 277                 /*
 278                  * We would block on opening a FIFO with no one else on the
 279                  * other end. Do what we used to do and add O_NONBLOCK to the
 280                  * open flags. JRA.
 281                  */
 282
 283                 if (file_existed && S_ISFIFO(psbuf->st_mode)) {
 284                         local_flags |= O_NONBLOCK;
 285                 }
 286 #endif
 287
 288                 /* Don't create files with Microsoft wildcard characters. */
 289                 if ((local_flags & O_CREAT) && !file_existed &&
 290                     ms_has_wild(path))  {
 291                         return NT_STATUS_OBJECT_NAME_INVALID;
 292                 }
 293
 294                 /* Actually do the open */
 295                 status = fd_open(conn, path, fsp, local_flags, unx_mode);
 296                 if (!NT_STATUS_IS_OK(status)) {
 297                         DEBUG(3,("Error opening file %s (%s) (local_flags=%d) "
 298                                  "(flags=%d)\n",
 299                                  path,nt_errstr(status),local_flags,flags));
 300                         return status;
 301                 }
 302
 303                 if ((local_flags & O_CREAT) && !file_existed) {
 304
 305                         /* Inherit the ACL if required */
 306                         if (lp_inherit_perms(SNUM(conn))) {
 307                                 inherit_access_acl(conn, parent_dir, path,
 308                                                    unx_mode);
 309                         }
 310
 311                         /* Change the owner if required. */
 312                         if (lp_inherit_owner(SNUM(conn))) {
 313                                 change_file_owner_to_parent(conn, parent_dir,
 314                                                             fsp);
 315                         }
 316
 317                         notify_fname(conn, NOTIFY_ACTION_ADDED,
 318                                      FILE_NOTIFY_CHANGE_FILE_NAME, path);
 319                 }
 320
 321         } else {
 322                 fsp->fh->fd = -1; /* What we used to call a stat open. */
 323         }
 324
 325         if (!file_existed) {
 326                 int ret;
 327
 328                 if (fsp->fh->fd == -1) {
 329                         ret = SMB_VFS_STAT(conn, path, psbuf);
 330                 } else {
 331                         ret = SMB_VFS_FSTAT(fsp,fsp->fh->fd,psbuf);
 332                         /* If we have an fd, this stat should succeed. */
 333                         if (ret == -1) {
 334                                 DEBUG(0,("Error doing fstat on open file %s "
 335                                          "(%s)\n", path,strerror(errno) ));
 336                         }
 337                 }
 338
 339                 /* For a non-io open, this stat failing means file not found. JRA */
 340                 if (ret == -1) {
 341                         status = map_nt_error_from_unix(errno);
 342                         fd_close(conn, fsp);
 343                         return status;
 344                 }
 345         }
 346
 347         /*
 348          * POSIX allows read-only opens of directories. We don't
 349          * want to do this (we use a different code path for this)
 350          * so catch a directory open and return an EISDIR. JRA.
 351          */
 352
 353         if(S_ISDIR(psbuf->st_mode)) {
 354                 fd_close(conn, fsp);
 355                 errno = EISDIR;
 356                 return NT_STATUS_FILE_IS_A_DIRECTORY;
 357         }
 358
 359         fsp->mode = psbuf->st_mode;
 360         fsp->file_id = file_id_sbuf(psbuf);
 361         fsp->vuid = req ? req->vuid : UID_FIELD_INVALID;
 362         fsp->file_pid = req ? req->smbpid : 0;
 363         fsp->can_lock = True;
 364         fsp->can_read = (access_mask & (FILE_READ_DATA)) ? True : False;
 365         if (!CAN_WRITE(conn)) {
 366                 fsp->can_write = False;
 367         } else {
 368                 fsp->can_write = (access_mask & (FILE_WRITE_DATA | FILE_APPEND_DATA)) ?
 369                         True : False;
 370         }
 371         fsp->print_file = False;
 372         fsp->modified = False;
 373         fsp->sent_oplock_break = NO_BREAK_SENT;
 374         fsp->is_directory = False;
 375         fsp->is_stat = False;
 376
 377         string_set(&fsp->fsp_name, path);
 378         fsp->wcp = NULL; /* Write cache pointer. */
 379
 380         DEBUG(2,("%s opened file %s read=%s write=%s (numopen=%d)\n",
 381                  *current_user_info.smb_name ?
 382                  current_user_info.smb_name : conn->user,fsp->fsp_name,
 383                  BOOLSTR(fsp->can_read), BOOLSTR(fsp->can_write),
 384                  conn->num_files_open + 1));
 385
 386         errno = 0;
 387         return NT_STATUS_OK;
 388 }
 389
 390 /*******************************************************************
 391  Return True if the filename is one of the special executable types.
 392 ********************************************************************/
 393
 394 static BOOL is_executable(const char *fname)
 395 {
 396         if ((fname = strrchr_m(fname,'.'))) {
 397                 if (strequal(fname,".com") ||
 398                     strequal(fname,".dll") ||
 399                     strequal(fname,".exe") ||
 400                     strequal(fname,".sym")) {
 401                         return True;
 402                 }
 403         }
 404         return False;
 405 }
 406
 407 /****************************************************************************
 408  Check if we can open a file with a share mode.
 409  Returns True if conflict, False if not.
 410 ****************************************************************************/
 411
 412 static BOOL share_conflict(struct share_mode_entry *entry,
 413                            uint32 access_mask,
 414                            uint32 share_access)
 415 {
 416         DEBUG(10,("share_conflict: entry->access_mask = 0x%x, "
 417                   "entry->share_access = 0x%x, "
 418                   "entry->private_options = 0x%x\n",
 419                   (unsigned int)entry->access_mask,
 420                   (unsigned int)entry->share_access,
 421                   (unsigned int)entry->private_options));
 422
 423         DEBUG(10,("share_conflict: access_mask = 0x%x, share_access = 0x%x\n",
 424                   (unsigned int)access_mask, (unsigned int)share_access));
 425
 426         if ((entry->access_mask & (FILE_WRITE_DATA|
 427                                    FILE_APPEND_DATA|
 428                                    FILE_READ_DATA|
 429                                    FILE_EXECUTE|
 430                                    DELETE_ACCESS)) == 0) {
 431                 DEBUG(10,("share_conflict: No conflict due to "
 432                           "entry->access_mask = 0x%x\n",
 433                           (unsigned int)entry->access_mask ));
 434                 return False;
 435         }
 436
 437         if ((access_mask & (FILE_WRITE_DATA|
 438                             FILE_APPEND_DATA|
 439                             FILE_READ_DATA|
 440                             FILE_EXECUTE|
 441                             DELETE_ACCESS)) == 0) {
 442                 DEBUG(10,("share_conflict: No conflict due to "
 443                           "access_mask = 0x%x\n",
 444                           (unsigned int)access_mask ));
 445                 return False;
 446         }
 447
 448 #if 1 /* JRA TEST - Superdebug. */
 449 #define CHECK_MASK(num, am, right, sa, share) \
 450         DEBUG(10,("share_conflict: [%d] am (0x%x) & right (0x%x) = 0x%x\n", \
 451                 (unsigned int)(num), (unsigned int)(am), \
 452                 (unsigned int)(right), (unsigned int)(am)&(right) )); \
 453         DEBUG(10,("share_conflict: [%d] sa (0x%x) & share (0x%x) = 0x%x\n", \
 454                 (unsigned int)(num), (unsigned int)(sa), \
 455                 (unsigned int)(share), (unsigned int)(sa)&(share) )); \
 456         if (((am) & (right)) && !((sa) & (share))) { \
 457                 DEBUG(10,("share_conflict: check %d conflict am = 0x%x, right = 0x%x, \
 458 sa = 0x%x, share = 0x%x\n", (num), (unsigned int)(am), (unsigned int)(right), (unsigned int)(sa), \
 459                         (unsigned int)(share) )); \
 460                 return True; \
 461         }
 462 #else
 463 #define CHECK_MASK(num, am, right, sa, share) \
 464         if (((am) & (right)) && !((sa) & (share))) { \
 465                 DEBUG(10,("share_conflict: check %d conflict am = 0x%x, right = 0x%x, \
 466 sa = 0x%x, share = 0x%x\n", (num), (unsigned int)(am), (unsigned int)(right), (unsigned int)(sa), \
 467                         (unsigned int)(share) )); \
 468                 return True; \
 469         }
 470 #endif
 471
 472         CHECK_MASK(1, entry->access_mask, FILE_WRITE_DATA | FILE_APPEND_DATA,
 473                    share_access, FILE_SHARE_WRITE);
 474         CHECK_MASK(2, access_mask, FILE_WRITE_DATA | FILE_APPEND_DATA,
 475                    entry->share_access, FILE_SHARE_WRITE);
 476
 477         CHECK_MASK(3, entry->access_mask, FILE_READ_DATA | FILE_EXECUTE,
 478                    share_access, FILE_SHARE_READ);
 479         CHECK_MASK(4, access_mask, FILE_READ_DATA | FILE_EXECUTE,
 480                    entry->share_access, FILE_SHARE_READ);
 481
 482         CHECK_MASK(5, entry->access_mask, DELETE_ACCESS,
 483                    share_access, FILE_SHARE_DELETE);
 484         CHECK_MASK(6, access_mask, DELETE_ACCESS,
 485                    entry->share_access, FILE_SHARE_DELETE);
 486
 487         DEBUG(10,("share_conflict: No conflict.\n"));
 488         return False;
 489 }
 490
 491 #if defined(DEVELOPER)
 492 static void validate_my_share_entries(int num,
 493                                       struct share_mode_entry *share_entry)
 494 {
 495         files_struct *fsp;
 496
 497         if (!procid_is_me(&share_entry->pid)) {
 498                 return;
 499         }
 500
 501         if (is_deferred_open_entry(share_entry) &&
 502             !open_was_deferred(share_entry->op_mid)) {
 503                 pstring str;
 504                 pstr_sprintf(str, "Got a deferred entry without a request: "
 505                              "PANIC: %s\n", share_mode_str(num, share_entry));
 506                 smb_panic(str);
 507         }
 508
 509         if (!is_valid_share_mode_entry(share_entry)) {
 510                 return;
 511         }
 512
 513         fsp = file_find_dif(share_entry->id,
 514                             share_entry->share_file_id);
 515         if (!fsp) {
 516                 DEBUG(0,("validate_my_share_entries: PANIC : %s\n",
 517                          share_mode_str(num, share_entry) ));
 518                 smb_panic("validate_my_share_entries: Cannot match a "
 519                           "share entry with an open file\n");
 520         }
 521
 522         if (is_deferred_open_entry(share_entry) ||
 523             is_unused_share_mode_entry(share_entry)) {
 524                 goto panic;
 525         }
 526
 527         if ((share_entry->op_type == NO_OPLOCK) &&
 528             (fsp->oplock_type == FAKE_LEVEL_II_OPLOCK)) {
 529                 /* Someone has already written to it, but I haven't yet
 530                  * noticed */
 531                 return;
 532         }
 533
 534         if (((uint16)fsp->oplock_type) != share_entry->op_type) {
 535                 goto panic;
 536         }
 537
 538         return;
 539
 540  panic:
 541         {
 542                 pstring str;
 543                 DEBUG(0,("validate_my_share_entries: PANIC : %s\n",
 544                          share_mode_str(num, share_entry) ));
 545                 slprintf(str, sizeof(str)-1, "validate_my_share_entries: "
 546                          "file %s, oplock_type = 0x%x, op_type = 0x%x\n",
 547                          fsp->fsp_name, (unsigned int)fsp->oplock_type,
 548                          (unsigned int)share_entry->op_type );
 549                 smb_panic(str);
 550         }
 551 }
 552 #endif
 553
 554 static BOOL is_stat_open(uint32 access_mask)
 555 {
 556         return (access_mask &&
 557                 ((access_mask & ~(SYNCHRONIZE_ACCESS| FILE_READ_ATTRIBUTES|
 558                                   FILE_WRITE_ATTRIBUTES))==0) &&
 559                 ((access_mask & (SYNCHRONIZE_ACCESS|FILE_READ_ATTRIBUTES|
 560                                  FILE_WRITE_ATTRIBUTES)) != 0));
 561 }
 562
 563 /****************************************************************************
 564  Deal with share modes
 565  Invarient: Share mode must be locked on entry and exit.
 566  Returns -1 on error, or number of share modes on success (may be zero).
 567 ****************************************************************************/
 568
 569 static NTSTATUS open_mode_check(connection_struct *conn,
 570                                 const char *fname,
 571                                 struct share_mode_lock *lck,
 572                                 uint32 access_mask,
 573                                 uint32 share_access,
 574                                 uint32 create_options,
 575                                 BOOL *file_existed)
 576 {
 577         int i;
 578
 579         if(lck->num_share_modes == 0) {
 580                 return NT_STATUS_OK;
 581         }
 582
 583         *file_existed = True;
 584
 585         if (is_stat_open(access_mask)) {
 586                 /* Stat open that doesn't trigger oplock breaks or share mode
 587                  * checks... ! JRA. */
 588                 return NT_STATUS_OK;
 589         }
 590
 591         /* A delete on close prohibits everything */
 592
 593         if (lck->delete_on_close) {
 594                 return NT_STATUS_DELETE_PENDING;
 595         }
 596
 597         /*
 598          * Check if the share modes will give us access.
 599          */
 600
 601 #if defined(DEVELOPER)
 602         for(i = 0; i < lck->num_share_modes; i++) {
 603                 validate_my_share_entries(i, &lck->share_modes[i]);
 604         }
 605 #endif
 606
 607         if (!lp_share_modes(SNUM(conn))) {
 608                 return NT_STATUS_OK;
 609         }
 610
 611         /* Now we check the share modes, after any oplock breaks. */
 612         for(i = 0; i < lck->num_share_modes; i++) {
 613
 614                 if (!is_valid_share_mode_entry(&lck->share_modes[i])) {
 615                         continue;
 616                 }
 617
 618                 /* someone else has a share lock on it, check to see if we can
 619                  * too */
 620                 if (share_conflict(&lck->share_modes[i],
 621                                    access_mask, share_access)) {
 622                         return NT_STATUS_SHARING_VIOLATION;
 623                 }
 624         }
 625
 626         return NT_STATUS_OK;
 627 }
 628
 629 static BOOL is_delete_request(files_struct *fsp) {
 630         return ((fsp->access_mask == DELETE_ACCESS) &&
 631                 (fsp->oplock_type == NO_OPLOCK));
 632 }
 633
 634 /*
 635  * 1) No files open at all or internal open: Grant whatever the client wants.
 636  *
 637  * 2) Exclusive (or batch) oplock around: If the requested access is a delete
 638  *    request, break if the oplock around is a batch oplock. If it's another
 639  *    requested access type, break.
 640  *
 641  * 3) Only level2 around: Grant level2 and do nothing else.
 642  */
 643
 644 static BOOL delay_for_oplocks(struct share_mode_lock *lck,
 645                               files_struct *fsp,
 646                               uint16 mid,
 647                               int pass_number,
 648                               int oplock_request)
 649 {
 650         int i;
 651         struct share_mode_entry *exclusive = NULL;
 652         BOOL valid_entry = False;
 653         BOOL delay_it = False;
 654         BOOL have_level2 = False;
 655         NTSTATUS status;
 656         char msg[MSG_SMB_SHARE_MODE_ENTRY_SIZE];
 657
 658         if (oplock_request & INTERNAL_OPEN_ONLY) {
 659                 fsp->oplock_type = NO_OPLOCK;
 660         }
 661
 662         if ((oplock_request & INTERNAL_OPEN_ONLY) || is_stat_open(fsp->access_mask)) {
 663                 return False;
 664         }
 665
 666         for (i=0; i<lck->num_share_modes; i++) {
 667
 668                 if (!is_valid_share_mode_entry(&lck->share_modes[i])) {
 669                         continue;
 670                 }
 671
 672                 /* At least one entry is not an invalid or deferred entry. */
 673                 valid_entry = True;
 674
 675                 if (pass_number == 1) {
 676                         if (BATCH_OPLOCK_TYPE(lck->share_modes[i].op_type)) {
 677                                 SMB_ASSERT(exclusive == NULL);
 678                                 exclusive = &lck->share_modes[i];
 679                         }
 680                 } else {
 681                         if (EXCLUSIVE_OPLOCK_TYPE(lck->share_modes[i].op_type)) {
 682                                 SMB_ASSERT(exclusive == NULL);
 683                                 exclusive = &lck->share_modes[i];
 684                         }
 685                 }
 686
 687                 if (lck->share_modes[i].op_type == LEVEL_II_OPLOCK) {
 688                         SMB_ASSERT(exclusive == NULL);
 689                         have_level2 = True;
 690                 }
 691         }
 692
 693         if (!valid_entry) {
 694                 /* All entries are placeholders or deferred.
 695                  * Directly grant whatever the client wants. */
 696                 if (fsp->oplock_type == NO_OPLOCK) {
 697                         /* Store a level2 oplock, but don't tell the client */
 698                         fsp->oplock_type = FAKE_LEVEL_II_OPLOCK;
 699                 }
 700                 return False;
 701         }
 702
 703         if (exclusive != NULL) { /* Found an exclusive oplock */
 704                 SMB_ASSERT(!have_level2);
 705                 delay_it = is_delete_request(fsp) ?
 706                         BATCH_OPLOCK_TYPE(exclusive->op_type) : True;
 707         }
 708
 709         if (EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type)) {
 710                 /* We can at most grant level2 as there are other
 711                  * level2 or NO_OPLOCK entries. */
 712                 fsp->oplock_type = LEVEL_II_OPLOCK;
 713         }
 714
 715         if ((fsp->oplock_type == NO_OPLOCK) && have_level2) {
 716                 /* Store a level2 oplock, but don't tell the client */
 717                 fsp->oplock_type = FAKE_LEVEL_II_OPLOCK;
 718         }
 719
 720         if (!delay_it) {
 721                 return False;
 722         }
 723
 724         /*
 725          * Send a break message to the oplock holder and delay the open for
 726          * our client.
 727          */
 728
 729         DEBUG(10, ("Sending break request to PID %s\n",
 730                    procid_str_static(&exclusive->pid)));
 731         exclusive->op_mid = mid;
 732
 733         /* Create the message. */
 734         share_mode_entry_to_message(msg, exclusive);
 735
 736         /* Add in the FORCE_OPLOCK_BREAK_TO_NONE bit in the message if set. We
 737            don't want this set in the share mode struct pointed to by lck. */
 738
 739         if (oplock_request & FORCE_OPLOCK_BREAK_TO_NONE) {
 740                 SSVAL(msg,6,exclusive->op_type | FORCE_OPLOCK_BREAK_TO_NONE);
 741         }
 742
 743         status = messaging_send_buf(smbd_messaging_context(), exclusive->pid,
 744                                     MSG_SMB_BREAK_REQUEST,
 745                                     (uint8 *)msg,
 746                                     MSG_SMB_SHARE_MODE_ENTRY_SIZE);
 747         if (!NT_STATUS_IS_OK(status)) {
 748                 DEBUG(3, ("Could not send oplock break message: %s\n",
 749                           nt_errstr(status)));
 750         }
 751
 752         return True;
 753 }
 754
 755 static BOOL request_timed_out(struct timeval request_time,
 756                               struct timeval timeout)
 757 {
 758         struct timeval now, end_time;
 759         GetTimeOfDay(&now);
 760         end_time = timeval_sum(&request_time, &timeout);
 761         return (timeval_compare(&end_time, &now) < 0);
 762 }
 763
 764 /****************************************************************************
 765  Handle the 1 second delay in returning a SHARING_VIOLATION error.
 766 ****************************************************************************/
 767
 768 static void defer_open(struct share_mode_lock *lck,
 769                        struct timeval request_time,
 770                        struct timeval timeout,
 771                        uint16 mid,
 772                        struct deferred_open_record *state)
 773 {
 774         int i;
 775
 776         /* Paranoia check */
 777
 778         for (i=0; i<lck->num_share_modes; i++) {
 779                 struct share_mode_entry *e = &lck->share_modes[i];
 780
 781                 if (!is_deferred_open_entry(e)) {
 782                         continue;
 783                 }
 784
 785                 if (procid_is_me(&e->pid) && (e->op_mid == mid)) {
 786                         DEBUG(0, ("Trying to defer an already deferred "
 787                                   "request: mid=%d, exiting\n", mid));
 788                         exit_server("attempt to defer a deferred request");
 789                 }
 790         }
 791
 792         /* End paranoia check */
 793
 794         DEBUG(10,("defer_open_sharing_error: time [%u.%06u] adding deferred "
 795                   "open entry for mid %u\n",
 796                   (unsigned int)request_time.tv_sec,
 797                   (unsigned int)request_time.tv_usec,
 798                   (unsigned int)mid));
 799
 800         if (!push_deferred_smb_message(mid, request_time, timeout,
 801                                        (char *)state, sizeof(*state))) {
 802                 exit_server("push_deferred_smb_message failed");
 803         }
 804         add_deferred_open(lck, mid, request_time, state->id);
 805
 806         /*
 807          * Push the MID of this packet on the signing queue.
 808          * We only do this once, the first time we push the packet
 809          * onto the deferred open queue, as this has a side effect
 810          * of incrementing the response sequence number.
 811          */
 812
 813         srv_defer_sign_response(mid);
 814 }
 815
 816
 817 /****************************************************************************
 818  On overwrite open ensure that the attributes match.
 819 ****************************************************************************/
 820
 821 static BOOL open_match_attributes(connection_struct *conn,
 822                                   const char *path,
 823                                   uint32 old_dos_attr,
 824                                   uint32 new_dos_attr,
 825                                   mode_t existing_unx_mode,
 826                                   mode_t new_unx_mode,
 827                                   mode_t *returned_unx_mode)
 828 {
 829         uint32 noarch_old_dos_attr, noarch_new_dos_attr;
 830
 831         noarch_old_dos_attr = (old_dos_attr & ~FILE_ATTRIBUTE_ARCHIVE);
 832         noarch_new_dos_attr = (new_dos_attr & ~FILE_ATTRIBUTE_ARCHIVE);
 833
 834         if((noarch_old_dos_attr == 0 && noarch_new_dos_attr != 0) ||
 835            (noarch_old_dos_attr != 0 && ((noarch_old_dos_attr & noarch_new_dos_attr) == noarch_old_dos_attr))) {
 836                 *returned_unx_mode = new_unx_mode;
 837         } else {
 838                 *returned_unx_mode = (mode_t)0;
 839         }
 840
 841         DEBUG(10,("open_match_attributes: file %s old_dos_attr = 0x%x, "
 842                   "existing_unx_mode = 0%o, new_dos_attr = 0x%x "
 843                   "returned_unx_mode = 0%o\n",
 844                   path,
 845                   (unsigned int)old_dos_attr,
 846                   (unsigned int)existing_unx_mode,
 847                   (unsigned int)new_dos_attr,
 848                   (unsigned int)*returned_unx_mode ));
 849
 850         /* If we're mapping SYSTEM and HIDDEN ensure they match. */
 851         if (lp_map_system(SNUM(conn)) || lp_store_dos_attributes(SNUM(conn))) {
 852                 if ((old_dos_attr & FILE_ATTRIBUTE_SYSTEM) &&
 853                     !(new_dos_attr & FILE_ATTRIBUTE_SYSTEM)) {
 854                         return False;
 855                 }
 856         }
 857         if (lp_map_hidden(SNUM(conn)) || lp_store_dos_attributes(SNUM(conn))) {
 858                 if ((old_dos_attr & FILE_ATTRIBUTE_HIDDEN) &&
 859                     !(new_dos_attr & FILE_ATTRIBUTE_HIDDEN)) {
 860                         return False;
 861                 }
 862         }
 863         return True;
 864 }
 865
 866 /****************************************************************************
 867  Special FCB or DOS processing in the case of a sharing violation.
 868  Try and find a duplicated file handle.
 869 ****************************************************************************/
 870
 871 static files_struct *fcb_or_dos_open(connection_struct *conn,
 872                                      const char *fname,
 873                                      struct file_id id,
 874                                      uint16 file_pid,
 875                                      uint16 vuid,
 876                                      uint32 access_mask,
 877                                      uint32 share_access,
 878                                      uint32 create_options)
 879 {
 880         files_struct *fsp;
 881         files_struct *dup_fsp;
 882
 883         DEBUG(5,("fcb_or_dos_open: attempting old open semantics for "
 884                  "file %s.\n", fname ));
 885
 886         for(fsp = file_find_di_first(id); fsp;
 887             fsp = file_find_di_next(fsp)) {
 888
 889                 DEBUG(10,("fcb_or_dos_open: checking file %s, fd = %d, "
 890                           "vuid = %u, file_pid = %u, private_options = 0x%x "
 891                           "access_mask = 0x%x\n", fsp->fsp_name,
 892                           fsp->fh->fd, (unsigned int)fsp->vuid,
 893                           (unsigned int)fsp->file_pid,
 894                           (unsigned int)fsp->fh->private_options,
 895                           (unsigned int)fsp->access_mask ));
 896
 897                 if (fsp->fh->fd != -1 &&
 898                     fsp->vuid == vuid &&
 899                     fsp->file_pid == file_pid &&
 900                     (fsp->fh->private_options & (NTCREATEX_OPTIONS_PRIVATE_DENY_DOS |
 901                                                  NTCREATEX_OPTIONS_PRIVATE_DENY_FCB)) &&
 902                     (fsp->access_mask & FILE_WRITE_DATA) &&
 903                     strequal(fsp->fsp_name, fname)) {
 904                         DEBUG(10,("fcb_or_dos_open: file match\n"));
 905                         break;
 906                 }
 907         }
 908
 909         if (!fsp) {
 910                 return NULL;
 911         }
 912
 913         /* quite an insane set of semantics ... */
 914         if (is_executable(fname) &&
 915             (fsp->fh->private_options & NTCREATEX_OPTIONS_PRIVATE_DENY_DOS)) {
 916                 DEBUG(10,("fcb_or_dos_open: file fail due to is_executable.\n"));
 917                 return NULL;
 918         }
 919
 920         /* We need to duplicate this fsp. */
 921         if (!NT_STATUS_IS_OK(dup_file_fsp(fsp, access_mask, share_access,
 922                                           create_options, &dup_fsp))) {
 923                 return NULL;
 924         }
 925
 926         return dup_fsp;
 927 }
 928
 929 /****************************************************************************
 930  Open a file with a share mode - old openX method - map into NTCreate.
 931 ****************************************************************************/
 932
 933 BOOL map_open_params_to_ntcreate(const char *fname, int deny_mode, int open_func,
 934                                  uint32 *paccess_mask,
 935                                  uint32 *pshare_mode,
 936                                  uint32 *pcreate_disposition,
 937                                  uint32 *pcreate_options)
 938 {
 939         uint32 access_mask;
 940         uint32 share_mode;
 941         uint32 create_disposition;
 942         uint32 create_options = 0;
 943
 944         DEBUG(10,("map_open_params_to_ntcreate: fname = %s, deny_mode = 0x%x, "
 945                   "open_func = 0x%x\n",
 946                   fname, (unsigned int)deny_mode, (unsigned int)open_func ));
 947
 948         /* Create the NT compatible access_mask. */
 949         switch (GET_OPENX_MODE(deny_mode)) {
 950                 case DOS_OPEN_EXEC: /* Implies read-only - used to be FILE_READ_DATA */
 951                 case DOS_OPEN_RDONLY:
 952                         access_mask = FILE_GENERIC_READ;
 953                         break;
 954                 case DOS_OPEN_WRONLY:
 955                         access_mask = FILE_GENERIC_WRITE;
 956                         break;
 957                 case DOS_OPEN_RDWR:
 958                 case DOS_OPEN_FCB:
 959                         access_mask = FILE_GENERIC_READ|FILE_GENERIC_WRITE;
 960                         break;
 961                 default:
 962                         DEBUG(10,("map_open_params_to_ntcreate: bad open mode = 0x%x\n",
 963                                   (unsigned int)GET_OPENX_MODE(deny_mode)));
 964                         return False;
 965         }
 966
 967         /* Create the NT compatible create_disposition. */
 968         switch (open_func) {
 969                 case OPENX_FILE_EXISTS_FAIL|OPENX_FILE_CREATE_IF_NOT_EXIST:
 970                         create_disposition = FILE_CREATE;
 971                         break;
 972
 973                 case OPENX_FILE_EXISTS_OPEN:
 974                         create_disposition = FILE_OPEN;
 975                         break;
 976
 977                 case OPENX_FILE_EXISTS_OPEN|OPENX_FILE_CREATE_IF_NOT_EXIST:
 978                         create_disposition = FILE_OPEN_IF;
 979                         break;
 980
 981                 case OPENX_FILE_EXISTS_TRUNCATE:
 982                         create_disposition = FILE_OVERWRITE;
 983                         break;
 984
 985                 case OPENX_FILE_EXISTS_TRUNCATE|OPENX_FILE_CREATE_IF_NOT_EXIST:
 986                         create_disposition = FILE_OVERWRITE_IF;
 987                         break;
 988
 989                 default:
 990                         /* From samba4 - to be confirmed. */
 991                         if (GET_OPENX_MODE(deny_mode) == DOS_OPEN_EXEC) {
 992                                 create_disposition = FILE_CREATE;
 993                                 break;
 994                         }
 995                         DEBUG(10,("map_open_params_to_ntcreate: bad "
 996                                   "open_func 0x%x\n", (unsigned int)open_func));
 997                         return False;
 998         }
 999
1000         /* Create the NT compatible share modes. */
1001         switch (GET_DENY_MODE(deny_mode)) {
1002                 case DENY_ALL:
1003                         share_mode = FILE_SHARE_NONE;
1004                         break;
1005
1006                 case DENY_WRITE:
1007                         share_mode = FILE_SHARE_READ;
1008                         break;
1009
1010                 case DENY_READ:
1011                         share_mode = FILE_SHARE_WRITE;
1012                         break;
1013
1014                 case DENY_NONE:
1015                         share_mode = FILE_SHARE_READ|FILE_SHARE_WRITE;
1016                         break;
1017
1018                 case DENY_DOS:
1019                         create_options |= NTCREATEX_OPTIONS_PRIVATE_DENY_DOS;
1020                         if (is_executable(fname)) {
1021                                 share_mode = FILE_SHARE_READ|FILE_SHARE_WRITE;
1022                         } else {
1023                                 if (GET_OPENX_MODE(deny_mode) == DOS_OPEN_RDONLY) {
1024                                         share_mode = FILE_SHARE_READ;
1025                                 } else {
1026                                         share_mode = FILE_SHARE_NONE;
1027                                 }
1028                         }
1029                         break;
1030
1031                 case DENY_FCB:
1032                         create_options |= NTCREATEX_OPTIONS_PRIVATE_DENY_FCB;
1033                         share_mode = FILE_SHARE_NONE;
1034                         break;
1035
1036                 default:
1037                         DEBUG(10,("map_open_params_to_ntcreate: bad deny_mode 0x%x\n",
1038                                 (unsigned int)GET_DENY_MODE(deny_mode) ));
1039                         return False;
1040         }
1041
1042         DEBUG(10,("map_open_params_to_ntcreate: file %s, access_mask = 0x%x, "
1043                   "share_mode = 0x%x, create_disposition = 0x%x, "
1044                   "create_options = 0x%x\n",
1045                   fname,
1046                   (unsigned int)access_mask,
1047                   (unsigned int)share_mode,
1048                   (unsigned int)create_disposition,
1049                   (unsigned int)create_options ));
1050
1051         if (paccess_mask) {
1052                 *paccess_mask = access_mask;
1053         }
1054         if (pshare_mode) {
1055                 *pshare_mode = share_mode;
1056         }
1057         if (pcreate_disposition) {
1058                 *pcreate_disposition = create_disposition;
1059         }
1060         if (pcreate_options) {
1061                 *pcreate_options = create_options;
1062         }
1063
1064         return True;
1065
1066 }
1067
1068 static void schedule_defer_open(struct share_mode_lock *lck,
1069                                 struct timeval request_time,
1070                                 uint16 mid)
1071 {
1072         struct deferred_open_record state;
1073
1074         /* This is a relative time, added to the absolute
1075            request_time value to get the absolute timeout time.
1076            Note that if this is the second or greater time we enter
1077            this codepath for this particular request mid then
1078            request_time is left as the absolute time of the *first*
1079            time this request mid was processed. This is what allows
1080            the request to eventually time out. */
1081
1082         struct timeval timeout;
1083
1084         /* Normally the smbd we asked should respond within
1085          * OPLOCK_BREAK_TIMEOUT seconds regardless of whether
1086          * the client did, give twice the timeout as a safety
1087          * measure here in case the other smbd is stuck
1088          * somewhere else. */
1089
1090         timeout = timeval_set(OPLOCK_BREAK_TIMEOUT*2, 0);
1091
1092         /* Nothing actually uses state.delayed_for_oplocks
1093            but it's handy to differentiate in debug messages
1094            between a 30 second delay due to oplock break, and
1095            a 1 second delay for share mode conflicts. */
1096
1097         state.delayed_for_oplocks = True;
1098         state.id = lck->id;
1099
1100         if (!request_timed_out(request_time, timeout)) {
1101                 defer_open(lck, request_time, timeout, mid, &state);
1102         }
1103 }
1104
1105 /****************************************************************************
1106  Open a file with a share mode.
1107 ****************************************************************************/
1108
1109 NTSTATUS open_file_ntcreate(connection_struct *conn,
1110                             struct smb_request *req,
1111                             const char *fname,
1112                             SMB_STRUCT_STAT *psbuf,
1113                             uint32 access_mask,         /* access bits (FILE_READ_DATA etc.) */
1114                             uint32 share_access,        /* share constants (FILE_SHARE_READ etc) */
1115                             uint32 create_disposition,  /* FILE_OPEN_IF etc. */
1116                             uint32 create_options,      /* options such as delete on close. */
1117                             uint32 new_dos_attributes,  /* attributes used for new file. */
1118                             int oplock_request,         /* internal Samba oplock codes. */
1119                                                         /* Information (FILE_EXISTS etc.) */
1120                             int *pinfo,
1121                             files_struct **result)
1122 {
1123         int flags=0;
1124         int flags2=0;
1125         BOOL file_existed = VALID_STAT(*psbuf);
1126         BOOL def_acl = False;
1127         BOOL posix_open = False;
1128         BOOL new_file_created = False;
1129         struct file_id id;
1130         NTSTATUS fsp_open = NT_STATUS_ACCESS_DENIED;
1131         files_struct *fsp = NULL;
1132         mode_t new_unx_mode = (mode_t)0;
1133         mode_t unx_mode = (mode_t)0;
1134         int info;
1135         uint32 existing_dos_attributes = 0;
1136         struct pending_message_list *pml = NULL;
1137         struct timeval request_time = timeval_zero();
1138         struct share_mode_lock *lck = NULL;
1139         uint32 open_access_mask = access_mask;
1140         NTSTATUS status;
1141         int ret_flock;
1142         char *parent_dir;
1143         const char *newname;
1144
1145         ZERO_STRUCT(id);
1146
1147         if (conn->printer) {
1148                 /*
1149                  * Printers are handled completely differently.
1150                  * Most of the passed parameters are ignored.
1151                  */
1152
1153                 if (pinfo) {
1154                         *pinfo = FILE_WAS_CREATED;
1155                 }
1156
1157                 DEBUG(10, ("open_file_ntcreate: printer open fname=%s\n", fname));
1158
1159                 return print_fsp_open(conn, fname, result);
1160         }
1161
1162         if (!parent_dirname_talloc(tmp_talloc_ctx(), fname, &parent_dir,
1163                                    &newname)) {
1164                 return NT_STATUS_NO_MEMORY;
1165         }
1166
1167         if (new_dos_attributes & FILE_FLAG_POSIX_SEMANTICS) {
1168                 posix_open = True;
1169                 unx_mode = (mode_t)(new_dos_attributes & ~FILE_FLAG_POSIX_SEMANTICS);
1170                 new_dos_attributes = 0;
1171         } else {
1172                 /* We add aARCH to this as this mode is only used if the file is
1173                  * created new. */
1174                 unx_mode = unix_mode(conn, new_dos_attributes | aARCH, fname,
1175                                      parent_dir);
1176         }
1177
1178         DEBUG(10, ("open_file_ntcreate: fname=%s, dos_attrs=0x%x "
1179                    "access_mask=0x%x share_access=0x%x "
1180                    "create_disposition = 0x%x create_options=0x%x "
1181                    "unix mode=0%o oplock_request=%d\n",
1182                    fname, new_dos_attributes, access_mask, share_access,
1183                    create_disposition, create_options, unx_mode,
1184                    oplock_request));
1185
1186         if ((req == NULL) && ((oplock_request & INTERNAL_OPEN_ONLY) == 0)) {
1187                 DEBUG(0, ("No smb request but not an internal only open!\n"));
1188                 return NT_STATUS_INTERNAL_ERROR;
1189         }
1190
1191         /*
1192          * Only non-internal opens can be deferred at all
1193          */
1194
1195         if ((req != NULL)
1196             && ((pml = get_open_deferred_message(req->mid)) != NULL)) {
1197                 struct deferred_open_record *state =
1198                         (struct deferred_open_record *)pml->private_data.data;
1199
1200                 /* Remember the absolute time of the original
1201                    request with this mid. We'll use it later to
1202                    see if this has timed out. */
1203
1204                 request_time = pml->request_time;
1205
1206                 /* Remove the deferred open entry under lock. */
1207                 lck = get_share_mode_lock(NULL, state->id, NULL, NULL);
1208                 if (lck == NULL) {
1209                         DEBUG(0, ("could not get share mode lock\n"));
1210                 } else {
1211                         del_deferred_open_entry(lck, req->mid);
1212                         TALLOC_FREE(lck);
1213                 }
1214
1215                 /* Ensure we don't reprocess this message. */
1216                 remove_deferred_open_smb_message(req->mid);
1217         }
1218
1219         status = check_name(conn, fname);
1220         if (!NT_STATUS_IS_OK(status)) {
1221                 return status;
1222         }
1223
1224         if (!posix_open) {
1225                 new_dos_attributes &= SAMBA_ATTRIBUTES_MASK;
1226                 if (file_existed) {
1227                         existing_dos_attributes = dos_mode(conn, fname, psbuf);
1228                 }
1229         }
1230
1231         /* ignore any oplock requests if oplocks are disabled */
1232         if (!lp_oplocks(SNUM(conn)) || global_client_failed_oplock_break ||
1233             IS_VETO_OPLOCK_PATH(conn, fname)) {
1234                 /* Mask off everything except the private Samba bits. */
1235                 oplock_request &= SAMBA_PRIVATE_OPLOCK_MASK;
1236         }
1237
1238         /* this is for OS/2 long file names - say we don't support them */
1239         if (!lp_posix_pathnames() && strstr(fname,".+,;=[].")) {
1240                 /* OS/2 Workplace shell fix may be main code stream in a later
1241                  * release. */
1242                 DEBUG(5,("open_file_ntcreate: OS/2 long filenames are not "
1243                          "supported.\n"));
1244                 if (use_nt_status()) {
1245                         return NT_STATUS_OBJECT_NAME_NOT_FOUND;
1246                 }
1247                 return NT_STATUS_DOS(ERRDOS, ERRcannotopen);
1248         }
1249
1250         switch( create_disposition ) {
1251                 /*
1252                  * Currently we're using FILE_SUPERSEDE as the same as
1253                  * FILE_OVERWRITE_IF but they really are
1254                  * different. FILE_SUPERSEDE deletes an existing file
1255                  * (requiring delete access) then recreates it.
1256                  */
1257                 case FILE_SUPERSEDE:
1258                         /* If file exists replace/overwrite. If file doesn't
1259                          * exist create. */
1260                         flags2 |= (O_CREAT | O_TRUNC);
1261                         break;
1262
1263                 case FILE_OVERWRITE_IF:
1264                         /* If file exists replace/overwrite. If file doesn't
1265                          * exist create. */
1266                         flags2 |= (O_CREAT | O_TRUNC);
1267                         break;
1268
1269                 case FILE_OPEN:
1270                         /* If file exists open. If file doesn't exist error. */
1271                         if (!file_existed) {
1272                                 DEBUG(5,("open_file_ntcreate: FILE_OPEN "
1273                                          "requested for file %s and file "
1274                                          "doesn't exist.\n", fname ));
1275                                 errno = ENOENT;
1276                                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
1277                         }
1278                         break;
1279
1280                 case FILE_OVERWRITE:
1281                         /* If file exists overwrite. If file doesn't exist
1282                          * error. */
1283                         if (!file_existed) {
1284                                 DEBUG(5,("open_file_ntcreate: FILE_OVERWRITE "
1285                                          "requested for file %s and file "
1286                                          "doesn't exist.\n", fname ));
1287                                 errno = ENOENT;
1288                                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
1289                         }
1290                         flags2 |= O_TRUNC;
1291                         break;
1292
1293                 case FILE_CREATE:
1294                         /* If file exists error. If file doesn't exist
1295                          * create. */
1296                         if (file_existed) {
1297                                 DEBUG(5,("open_file_ntcreate: FILE_CREATE "
1298                                          "requested for file %s and file "
1299                                          "already exists.\n", fname ));
1300                                 if (S_ISDIR(psbuf->st_mode)) {
1301                                         errno = EISDIR;
1302                                 } else {
1303                                         errno = EEXIST;
1304                                 }
1305                                 return map_nt_error_from_unix(errno);
1306                         }
1307                         flags2 |= (O_CREAT|O_EXCL);
1308                         break;
1309
1310                 case FILE_OPEN_IF:
1311                         /* If file exists open. If file doesn't exist
1312                          * create. */
1313                         flags2 |= O_CREAT;
1314                         break;
1315
1316                 default:
1317                         return NT_STATUS_INVALID_PARAMETER;
1318         }
1319
1320         /* We only care about matching attributes on file exists and
1321          * overwrite. */
1322
1323         if (!posix_open && file_existed && ((create_disposition == FILE_OVERWRITE) ||
1324                              (create_disposition == FILE_OVERWRITE_IF))) {
1325                 if (!open_match_attributes(conn, fname,
1326                                            existing_dos_attributes,
1327                                            new_dos_attributes, psbuf->st_mode,
1328                                            unx_mode, &new_unx_mode)) {
1329                         DEBUG(5,("open_file_ntcreate: attributes missmatch "
1330                                  "for file %s (%x %x) (0%o, 0%o)\n",
1331                                  fname, existing_dos_attributes,
1332                                  new_dos_attributes,
1333                                  (unsigned int)psbuf->st_mode,
1334                                  (unsigned int)unx_mode ));
1335                         errno = EACCES;
1336                         return NT_STATUS_ACCESS_DENIED;
1337                 }
1338         }
1339
1340         /* This is a nasty hack - must fix... JRA. */
1341         if (access_mask == MAXIMUM_ALLOWED_ACCESS) {
1342                 open_access_mask = access_mask = FILE_GENERIC_ALL;
1343         }
1344
1345         /*
1346          * Convert GENERIC bits to specific bits.
1347          */
1348
1349         se_map_generic(&access_mask, &file_generic_mapping);
1350         open_access_mask = access_mask;
1351
1352         if (flags2 & O_TRUNC) {
1353                 open_access_mask |= FILE_WRITE_DATA; /* This will cause oplock breaks. */
1354         }
1355
1356         DEBUG(10, ("open_file_ntcreate: fname=%s, after mapping "
1357                    "access_mask=0x%x\n", fname, access_mask ));
1358
1359         /*
1360          * Note that we ignore the append flag as append does not
1361          * mean the same thing under DOS and Unix.
1362          */
1363
1364         if (access_mask & (FILE_WRITE_DATA | FILE_APPEND_DATA)) {
1365                 /* DENY_DOS opens are always underlying read-write on the
1366                    file handle, no matter what the requested access mask
1367                     says. */
1368                 if ((create_options & NTCREATEX_OPTIONS_PRIVATE_DENY_DOS) ||
1369                         access_mask & (FILE_READ_ATTRIBUTES|FILE_READ_DATA|FILE_READ_EA|FILE_EXECUTE)) {
1370                         flags = O_RDWR;
1371                 } else {
1372                         flags = O_WRONLY;
1373                 }
1374         } else {
1375                 flags = O_RDONLY;
1376         }
1377
1378         /*
1379          * Currently we only look at FILE_WRITE_THROUGH for create options.
1380          */
1381
1382 #if defined(O_SYNC)
1383         if ((create_options & FILE_WRITE_THROUGH) && lp_strict_sync(SNUM(conn))) {
1384                 flags2 |= O_SYNC;
1385         }
1386 #endif /* O_SYNC */
1387
1388         if (posix_open & (access_mask & FILE_APPEND_DATA)) {
1389                 flags2 |= O_APPEND;
1390         }
1391
1392         if (!posix_open && !CAN_WRITE(conn)) {
1393                 /*
1394                  * We should really return a permission denied error if either
1395                  * O_CREAT or O_TRUNC are set, but for compatibility with
1396                  * older versions of Samba we just AND them out.
1397                  */
1398                 flags2 &= ~(O_CREAT|O_TRUNC);
1399         }
1400
1401         /*
1402          * Ensure we can't write on a read-only share or file.
1403          */
1404
1405         if (flags != O_RDONLY && file_existed &&
1406             (!CAN_WRITE(conn) || IS_DOS_READONLY(existing_dos_attributes))) {
1407                 DEBUG(5,("open_file_ntcreate: write access requested for "
1408                          "file %s on read only %s\n",
1409                          fname, !CAN_WRITE(conn) ? "share" : "file" ));
1410                 errno = EACCES;
1411                 return NT_STATUS_ACCESS_DENIED;
1412         }
1413
1414         status = file_new(conn, &fsp);
1415         if(!NT_STATUS_IS_OK(status)) {
1416                 return status;
1417         }
1418
1419         fsp->file_id = file_id_sbuf(psbuf);
1420         fsp->share_access = share_access;
1421         fsp->fh->private_options = create_options;
1422         fsp->access_mask = open_access_mask; /* We change this to the
1423                                               * requested access_mask after
1424                                               * the open is done. */
1425         fsp->posix_open = posix_open;
1426
1427         /* Ensure no SAMBA_PRIVATE bits can be set. */
1428         fsp->oplock_type = (oplock_request & ~SAMBA_PRIVATE_OPLOCK_MASK);
1429
1430         if (timeval_is_zero(&request_time)) {
1431                 request_time = fsp->open_time;
1432         }
1433
1434         if (file_existed) {
1435                 id = file_id_sbuf(psbuf);
1436
1437                 lck = get_share_mode_lock(NULL, id,
1438                                           conn->connectpath,
1439                                           fname);
1440
1441                 if (lck == NULL) {
1442                         file_free(fsp);
1443                         DEBUG(0, ("Could not get share mode lock\n"));
1444                         return NT_STATUS_SHARING_VIOLATION;
1445                 }
1446
1447                 /* First pass - send break only on batch oplocks. */
1448                 if ((req != NULL)
1449                     && delay_for_oplocks(lck, fsp, req->mid, 1,
1450                                          oplock_request)) {
1451                         schedule_defer_open(lck, request_time, req->mid);
1452                         TALLOC_FREE(lck);
1453                         file_free(fsp);
1454                         return NT_STATUS_SHARING_VIOLATION;
1455                 }
1456
1457                 /* Use the client requested access mask here, not the one we
1458                  * open with. */
1459                 status = open_mode_check(conn, fname, lck,
1460                                          access_mask, share_access,
1461                                          create_options, &file_existed);
1462
1463                 if (NT_STATUS_IS_OK(status)) {
1464                         /* We might be going to allow this open. Check oplock
1465                          * status again. */
1466                         /* Second pass - send break for both batch or
1467                          * exclusive oplocks. */
1468                         if ((req != NULL)
1469                              && delay_for_oplocks(lck, fsp, req->mid, 2,
1470                                                   oplock_request)) {
1471                                 schedule_defer_open(lck, request_time,
1472                                                     req->mid);
1473                                 TALLOC_FREE(lck);
1474                                 file_free(fsp);
1475                                 return NT_STATUS_SHARING_VIOLATION;
1476                         }
1477                 }
1478
1479                 if (NT_STATUS_EQUAL(status, NT_STATUS_DELETE_PENDING)) {
1480                         /* DELETE_PENDING is not deferred for a second */
1481                         TALLOC_FREE(lck);
1482                         file_free(fsp);
1483                         return status;
1484                 }
1485
1486                 if (!NT_STATUS_IS_OK(status)) {
1487                         uint32 can_access_mask;
1488                         BOOL can_access = True;
1489
1490                         SMB_ASSERT(NT_STATUS_EQUAL(status, NT_STATUS_SHARING_VIOLATION));
1491
1492                         /* Check if this can be done with the deny_dos and fcb
1493                          * calls. */
1494                         if (create_options &
1495                             (NTCREATEX_OPTIONS_PRIVATE_DENY_DOS|
1496                              NTCREATEX_OPTIONS_PRIVATE_DENY_FCB)) {
1497                                 files_struct *fsp_dup;
1498
1499                                 if (req == NULL) {
1500                                         DEBUG(0, ("DOS open without an SMB "
1501                                                   "request!\n"));
1502                                         TALLOC_FREE(lck);
1503                                         file_free(fsp);
1504                                         return NT_STATUS_INTERNAL_ERROR;
1505                                 }
1506
1507                                 /* Use the client requested access mask here,
1508                                  * not the one we open with. */
1509                                 fsp_dup = fcb_or_dos_open(conn, fname, id,
1510                                                           req->smbpid,
1511                                                           req->vuid,
1512                                                           access_mask,
1513                                                           share_access,
1514                                                           create_options);
1515
1516                                 if (fsp_dup) {
1517                                         TALLOC_FREE(lck);
1518                                         file_free(fsp);
1519                                         if (pinfo) {
1520                                                 *pinfo = FILE_WAS_OPENED;
1521                                         }
1522                                         conn->num_files_open++;
1523                                         *result = fsp_dup;
1524                                         return NT_STATUS_OK;
1525                                 }
1526                         }
1527
1528                         /*
1529                          * This next line is a subtlety we need for
1530                          * MS-Access. If a file open will fail due to share
1531                          * permissions and also for security (access) reasons,
1532                          * we need to return the access failed error, not the
1533                          * share error. We can't open the file due to kernel
1534                          * oplock deadlock (it's possible we failed above on
1535                          * the open_mode_check()) so use a userspace check.
1536                          */
1537
1538                         if (flags & O_RDWR) {
1539                                 can_access_mask = FILE_READ_DATA|FILE_WRITE_DATA;
1540                         } else if (flags & O_WRONLY) {
1541                                 can_access_mask = FILE_WRITE_DATA;
1542                         } else {
1543                                 can_access_mask = FILE_READ_DATA;
1544                         }
1545
1546                         if (((can_access_mask & FILE_WRITE_DATA) && !CAN_WRITE(conn)) ||
1547                             !can_access_file(conn,fname,psbuf,can_access_mask)) {
1548                                 can_access = False;
1549                         }
1550
1551                         /*
1552                          * If we're returning a share violation, ensure we
1553                          * cope with the braindead 1 second delay.
1554                          */
1555
1556                         if (!(oplock_request & INTERNAL_OPEN_ONLY) &&
1557                             lp_defer_sharing_violations()) {
1558                                 struct timeval timeout;
1559                                 struct deferred_open_record state;
1560                                 int timeout_usecs;
1561
1562                                 /* this is a hack to speed up torture tests
1563                                    in 'make test' */
1564                                 timeout_usecs = lp_parm_int(SNUM(conn),
1565                                                             "smbd","sharedelay",
1566                                                             SHARING_VIOLATION_USEC_WAIT);
1567
1568                                 /* This is a relative time, added to the absolute
1569                                    request_time value to get the absolute timeout time.
1570                                    Note that if this is the second or greater time we enter
1571                                    this codepath for this particular request mid then
1572                                    request_time is left as the absolute time of the *first*
1573                                    time this request mid was processed. This is what allows
1574                                    the request to eventually time out. */
1575
1576                                 timeout = timeval_set(0, timeout_usecs);
1577
1578                                 /* Nothing actually uses state.delayed_for_oplocks
1579                                    but it's handy to differentiate in debug messages
1580                                    between a 30 second delay due to oplock break, and
1581                                    a 1 second delay for share mode conflicts. */
1582
1583                                 state.delayed_for_oplocks = False;
1584                                 state.id = id;
1585
1586                                 if ((req != NULL)
1587                                     && !request_timed_out(request_time,
1588                                                           timeout)) {
1589                                         defer_open(lck, request_time, timeout,
1590                                                    req->mid, &state);
1591                                 }
1592                         }
1593
1594                         TALLOC_FREE(lck);
1595                         if (can_access) {
1596                                 /*
1597                                  * We have detected a sharing violation here
1598                                  * so return the correct error code
1599                                  */
1600                                 status = NT_STATUS_SHARING_VIOLATION;
1601                         } else {
1602                                 status = NT_STATUS_ACCESS_DENIED;
1603                         }
1604                         file_free(fsp);
1605                         return status;
1606                 }
1607
1608                 /*
1609                  * We exit this block with the share entry *locked*.....
1610                  */
1611         }
1612
1613         SMB_ASSERT(!file_existed || (lck != NULL));
1614
1615         /*
1616          * Ensure we pay attention to default ACLs on directories if required.
1617          */
1618
1619         if ((flags2 & O_CREAT) && lp_inherit_acls(SNUM(conn)) &&
1620             (def_acl = directory_has_default_acl(conn, parent_dir))) {
1621                 unx_mode = 0777;
1622         }
1623
1624         DEBUG(4,("calling open_file with flags=0x%X flags2=0x%X mode=0%o, "
1625                 "access_mask = 0x%x, open_access_mask = 0x%x\n",
1626                  (unsigned int)flags, (unsigned int)flags2,
1627                  (unsigned int)unx_mode, (unsigned int)access_mask,
1628                  (unsigned int)open_access_mask));
1629
1630         /*
1631          * open_file strips any O_TRUNC flags itself.
1632          */
1633
1634         fsp_open = open_file(fsp, conn, req, parent_dir, newname, fname, psbuf,
1635                              flags|flags2, unx_mode, access_mask,
1636                              open_access_mask);
1637
1638         if (!NT_STATUS_IS_OK(fsp_open)) {
1639                 if (lck != NULL) {
1640                         TALLOC_FREE(lck);
1641                 }
1642                 file_free(fsp);
1643                 return fsp_open;
1644         }
1645
1646         if (!file_existed) {
1647
1648                 /*
1649                  * Deal with the race condition where two smbd's detect the
1650                  * file doesn't exist and do the create at the same time. One
1651                  * of them will win and set a share mode, the other (ie. this
1652                  * one) should check if the requested share mode for this
1653                  * create is allowed.
1654                  */
1655
1656                 /*
1657                  * Now the file exists and fsp is successfully opened,
1658                  * fsp->dev and fsp->inode are valid and should replace the
1659                  * dev=0,inode=0 from a non existent file. Spotted by
1660                  * Nadav Danieli <nadavd@exanet.com>. JRA.
1661                  */
1662
1663                 id = fsp->file_id;
1664
1665                 lck = get_share_mode_lock(NULL, id,
1666                                           conn->connectpath,
1667                                           fname);
1668
1669                 if (lck == NULL) {
1670                         DEBUG(0, ("open_file_ntcreate: Could not get share "
1671                                   "mode lock for %s\n", fname));
1672                         fd_close(conn, fsp);
1673                         file_free(fsp);
1674                         return NT_STATUS_SHARING_VIOLATION;
1675                 }
1676
1677                 /* First pass - send break only on batch oplocks. */
1678                 if ((req != NULL)
1679                     && delay_for_oplocks(lck, fsp, req->mid, 1,
1680                                          oplock_request)) {
1681                         schedule_defer_open(lck, request_time, req->mid);
1682                         TALLOC_FREE(lck);
1683                         fd_close(conn, fsp);
1684                         file_free(fsp);
1685                         return NT_STATUS_SHARING_VIOLATION;
1686                 }
1687
1688                 status = open_mode_check(conn, fname, lck,
1689                                          access_mask, share_access,
1690                                          create_options, &file_existed);
1691
1692                 if (NT_STATUS_IS_OK(status)) {
1693                         /* We might be going to allow this open. Check oplock
1694                          * status again. */
1695                         /* Second pass - send break for both batch or
1696                          * exclusive oplocks. */
1697                         if ((req != NULL)
1698                             && delay_for_oplocks(lck, fsp, req->mid, 2,
1699                                                  oplock_request)) {
1700                                 schedule_defer_open(lck, request_time,
1701                                                     req->mid);
1702                                 TALLOC_FREE(lck);
1703                                 fd_close(conn, fsp);
1704                                 file_free(fsp);
1705                                 return NT_STATUS_SHARING_VIOLATION;
1706                         }
1707                 }
1708
1709                 if (!NT_STATUS_IS_OK(status)) {
1710                         struct deferred_open_record state;
1711
1712                         fd_close(conn, fsp);
1713                         file_free(fsp);
1714
1715                         state.delayed_for_oplocks = False;
1716                         state.id = id;
1717
1718                         /* Do it all over again immediately. In the second
1719                          * round we will find that the file existed and handle
1720                          * the DELETE_PENDING and FCB cases correctly. No need
1721                          * to duplicate the code here. Essentially this is a
1722                          * "goto top of this function", but don't tell
1723                          * anybody... */
1724
1725                         if (req != NULL) {
1726                                 defer_open(lck, request_time, timeval_zero(),
1727                                            req->mid, &state);
1728                         }
1729                         TALLOC_FREE(lck);
1730                         return status;
1731                 }
1732
1733                 /*
1734                  * We exit this block with the share entry *locked*.....
1735                  */
1736
1737         }
1738
1739         SMB_ASSERT(lck != NULL);
1740
1741         /* note that we ignore failure for the following. It is
1742            basically a hack for NFS, and NFS will never set one of
1743            these only read them. Nobody but Samba can ever set a deny
1744            mode and we have already checked our more authoritative
1745            locking database for permission to set this deny mode. If
1746            the kernel refuses the operations then the kernel is wrong.
1747            note that GPFS supports it as well - jmcd */
1748
1749         ret_flock = SMB_VFS_KERNEL_FLOCK(fsp, fsp->fh->fd, share_access);
1750         if(ret_flock == -1 ){
1751
1752                 TALLOC_FREE(lck);
1753                 fd_close(conn, fsp);
1754                 file_free(fsp);
1755
1756                 return NT_STATUS_SHARING_VIOLATION;
1757         }
1758
1759         /*
1760          * At this point onwards, we can guarentee that the share entry
1761          * is locked, whether we created the file or not, and that the
1762          * deny mode is compatible with all current opens.
1763          */
1764
1765         /*
1766          * If requested, truncate the file.
1767          */
1768
1769         if (flags2&O_TRUNC) {
1770                 /*
1771                  * We are modifing the file after open - update the stat
1772                  * struct..
1773                  */
1774                 if ((SMB_VFS_FTRUNCATE(fsp,fsp->fh->fd,0) == -1) ||
1775                     (SMB_VFS_FSTAT(fsp,fsp->fh->fd,psbuf)==-1)) {
1776                         status = map_nt_error_from_unix(errno);
1777                         TALLOC_FREE(lck);
1778                         fd_close(conn,fsp);
1779                         file_free(fsp);
1780                         return status;
1781                 }
1782         }
1783
1784         /* Record the options we were opened with. */
1785         fsp->share_access = share_access;
1786         fsp->fh->private_options = create_options;
1787         fsp->access_mask = access_mask;
1788
1789         if (file_existed) {
1790                 /* stat opens on existing files don't get oplocks. */
1791                 if (is_stat_open(open_access_mask)) {
1792                         fsp->oplock_type = NO_OPLOCK;
1793                 }
1794
1795                 if (!(flags2 & O_TRUNC)) {
1796                         info = FILE_WAS_OPENED;
1797                 } else {
1798                         info = FILE_WAS_OVERWRITTEN;
1799                 }
1800         } else {
1801                 info = FILE_WAS_CREATED;
1802         }
1803
1804         if (pinfo) {
1805                 *pinfo = info;
1806         }
1807
1808         /*
1809          * Setup the oplock info in both the shared memory and
1810          * file structs.
1811          */
1812
1813         if ((fsp->oplock_type != NO_OPLOCK) &&
1814             (fsp->oplock_type != FAKE_LEVEL_II_OPLOCK)) {
1815                 if (!set_file_oplock(fsp, fsp->oplock_type)) {
1816                         /* Could not get the kernel oplock */
1817                         fsp->oplock_type = NO_OPLOCK;
1818                 }
1819         }
1820
1821         if (info == FILE_WAS_OVERWRITTEN || info == FILE_WAS_CREATED || info == FILE_WAS_SUPERSEDED) {
1822                 new_file_created = True;
1823         }
1824
1825         set_share_mode(lck, fsp, current_user.ut.uid, 0, fsp->oplock_type, new_file_created);
1826
1827         /* Handle strange delete on close create semantics. */
1828         if ((create_options & FILE_DELETE_ON_CLOSE) && can_set_initial_delete_on_close(lck)) {
1829                 status = can_set_delete_on_close(fsp, True, new_dos_attributes);
1830
1831                 if (!NT_STATUS_IS_OK(status)) {
1832                         /* Remember to delete the mode we just added. */
1833                         del_share_mode(lck, fsp);
1834                         TALLOC_FREE(lck);
1835                         fd_close(conn,fsp);
1836                         file_free(fsp);
1837                         return status;
1838                 }
1839                 /* Note that here we set the *inital* delete on close flag,
1840                    not the regular one. The magic gets handled in close. */
1841                 fsp->initial_delete_on_close = True;
1842         }
1843
1844         if (new_file_created) {
1845                 /* Files should be initially set as archive */
1846                 if (lp_map_archive(SNUM(conn)) ||
1847                     lp_store_dos_attributes(SNUM(conn))) {
1848                         if (!posix_open) {
1849                                 file_set_dosmode(conn, fname,
1850                                          new_dos_attributes | aARCH, NULL,
1851                                          parent_dir);
1852                         }
1853                 }
1854         }
1855
1856         /*
1857          * Take care of inherited ACLs on created files - if default ACL not
1858          * selected.
1859          */
1860
1861         if (!posix_open && !file_existed && !def_acl) {
1862
1863                 int saved_errno = errno; /* We might get ENOSYS in the next
1864                                           * call.. */
1865
1866                 if (SMB_VFS_FCHMOD_ACL(fsp, fsp->fh->fd, unx_mode) == -1 &&
1867                     errno == ENOSYS) {
1868                         errno = saved_errno; /* Ignore ENOSYS */
1869                 }
1870
1871         } else if (new_unx_mode) {
1872
1873                 int ret = -1;
1874
1875                 /* Attributes need changing. File already existed. */
1876
1877                 {
1878                         int saved_errno = errno; /* We might get ENOSYS in the
1879                                                   * next call.. */
1880                         ret = SMB_VFS_FCHMOD_ACL(fsp, fsp->fh->fd,
1881                                                  new_unx_mode);
1882
1883                         if (ret == -1 && errno == ENOSYS) {
1884                                 errno = saved_errno; /* Ignore ENOSYS */
1885                         } else {
1886                                 DEBUG(5, ("open_file_ntcreate: reset "
1887                                           "attributes of file %s to 0%o\n",
1888                                           fname, (unsigned int)new_unx_mode));
1889                                 ret = 0; /* Don't do the fchmod below. */
1890                         }
1891                 }
1892
1893                 if ((ret == -1) &&
1894                     (SMB_VFS_FCHMOD(fsp, fsp->fh->fd, new_unx_mode) == -1))
1895                         DEBUG(5, ("open_file_ntcreate: failed to reset "
1896                                   "attributes of file %s to 0%o\n",
1897                                   fname, (unsigned int)new_unx_mode));
1898         }
1899
1900         /* If this is a successful open, we must remove any deferred open
1901          * records. */
1902         if (req != NULL) {
1903                 del_deferred_open_entry(lck, req->mid);
1904         }
1905         TALLOC_FREE(lck);
1906
1907         conn->num_files_open++;
1908
1909         *result = fsp;
1910         return NT_STATUS_OK;
1911 }
1912
1913 /****************************************************************************
1914  Open a file for for write to ensure that we can fchmod it.
1915 ****************************************************************************/
1916
1917 NTSTATUS open_file_fchmod(connection_struct *conn, const char *fname,
1918                           SMB_STRUCT_STAT *psbuf, files_struct **result)
1919 {
1920         files_struct *fsp = NULL;
1921         NTSTATUS status;
1922
1923         if (!VALID_STAT(*psbuf)) {
1924                 return NT_STATUS_INVALID_PARAMETER;
1925         }
1926
1927         status = file_new(conn, &fsp);
1928         if(!NT_STATUS_IS_OK(status)) {
1929                 return status;
1930         }
1931
1932         /* note! we must use a non-zero desired access or we don't get
1933            a real file descriptor. Oh what a twisted web we weave. */
1934         status = open_file(fsp, conn, NULL, NULL, NULL, fname, psbuf, O_WRONLY,
1935                            0, FILE_WRITE_DATA, FILE_WRITE_DATA);
1936
1937         /*
1938          * This is not a user visible file open.
1939          * Don't set a share mode and don't increment
1940          * the conn->num_files_open.
1941          */
1942
1943         if (!NT_STATUS_IS_OK(status)) {
1944                 file_free(fsp);
1945                 return status;
1946         }
1947
1948         *result = fsp;
1949         return NT_STATUS_OK;
1950 }
1951
1952 /****************************************************************************
1953  Close the fchmod file fd - ensure no locks are lost.
1954 ****************************************************************************/
1955
1956 NTSTATUS close_file_fchmod(files_struct *fsp)
1957 {
1958         NTSTATUS status = fd_close(fsp->conn, fsp);
1959         file_free(fsp);
1960         return status;
1961 }
1962
1963 static NTSTATUS mkdir_internal(connection_struct *conn,
1964                                 const char *name,
1965                                 uint32 file_attributes,
1966                                 SMB_STRUCT_STAT *psbuf)
1967 {
1968         mode_t mode;
1969         char *parent_dir;
1970         const char *dirname;
1971         NTSTATUS status;
1972
1973         if(!CAN_WRITE(conn)) {
1974                 DEBUG(5,("mkdir_internal: failing create on read-only share "
1975                          "%s\n", lp_servicename(SNUM(conn))));
1976                 return NT_STATUS_ACCESS_DENIED;
1977         }
1978
1979         status = check_name(conn, name);
1980         if (!NT_STATUS_IS_OK(status)) {
1981                 return status;
1982         }
1983
1984         if (!parent_dirname_talloc(tmp_talloc_ctx(), name, &parent_dir,
1985                                    &dirname)) {
1986                 return NT_STATUS_NO_MEMORY;
1987         }
1988
1989         if (file_attributes & FILE_FLAG_POSIX_SEMANTICS) {
1990                 mode = (mode_t)(file_attributes & ~FILE_FLAG_POSIX_SEMANTICS);
1991         } else {
1992                 mode = unix_mode(conn, aDIR, name, parent_dir);
1993         }
1994
1995         if (SMB_VFS_MKDIR(conn, name, mode) != 0) {
1996                 return map_nt_error_from_unix(errno);
1997         }
1998
1999         /* Ensure we're checking for a symlink here.... */
2000         /* We don't want to get caught by a symlink racer. */
2001
2002         if (SMB_VFS_LSTAT(conn, name, psbuf) == -1) {
2003                 DEBUG(2, ("Could not stat directory '%s' just created: %s\n",
2004                           name, strerror(errno)));
2005                 return map_nt_error_from_unix(errno);
2006         }
2007
2008         if (!S_ISDIR(psbuf->st_mode)) {
2009                 DEBUG(0, ("Directory just '%s' created is not a directory\n",
2010                           name));
2011                 return NT_STATUS_ACCESS_DENIED;
2012         }
2013
2014         if (lp_inherit_perms(SNUM(conn))) {
2015                 inherit_access_acl(conn, parent_dir, name, mode);
2016         }
2017
2018         if (!(file_attributes & FILE_FLAG_POSIX_SEMANTICS)) {
2019                 /*
2020                  * Check if high bits should have been set,
2021                  * then (if bits are missing): add them.
2022                  * Consider bits automagically set by UNIX, i.e. SGID bit from parent
2023                  * dir.
2024                  */
2025                 if (mode & ~(S_IRWXU|S_IRWXG|S_IRWXO) && (mode & ~psbuf->st_mode)) {
2026                         SMB_VFS_CHMOD(conn, name,
2027                                       psbuf->st_mode | (mode & ~psbuf->st_mode));
2028                 }
2029         }
2030
2031         /* Change the owner if required. */
2032         if (lp_inherit_owner(SNUM(conn))) {
2033                 change_dir_owner_to_parent(conn, parent_dir, name, psbuf);
2034         }
2035
2036         notify_fname(conn, NOTIFY_ACTION_ADDED, FILE_NOTIFY_CHANGE_DIR_NAME,
2037                      name);
2038
2039         return NT_STATUS_OK;
2040 }
2041
2042 /****************************************************************************
2043  Open a directory from an NT SMB call.
2044 ****************************************************************************/
2045
2046 NTSTATUS open_directory(connection_struct *conn,
2047                         struct smb_request *req,
2048                         const char *fname,
2049                         SMB_STRUCT_STAT *psbuf,
2050                         uint32 access_mask,
2051                         uint32 share_access,
2052                         uint32 create_disposition,
2053                         uint32 create_options,
2054                         uint32 file_attributes,
2055                         int *pinfo,
2056                         files_struct **result)
2057 {
2058         files_struct *fsp = NULL;
2059         BOOL dir_existed = VALID_STAT(*psbuf) ? True : False;
2060         struct share_mode_lock *lck = NULL;
2061         NTSTATUS status;
2062         int info = 0;
2063
2064         DEBUG(5,("open_directory: opening directory %s, access_mask = 0x%x, "
2065                  "share_access = 0x%x create_options = 0x%x, "
2066                  "create_disposition = 0x%x, file_attributes = 0x%x\n",
2067                  fname,
2068                  (unsigned int)access_mask,
2069                  (unsigned int)share_access,
2070                  (unsigned int)create_options,
2071                  (unsigned int)create_disposition,
2072                  (unsigned int)file_attributes));
2073
2074         if (is_ntfs_stream_name(fname)) {
2075                 DEBUG(0,("open_directory: %s is a stream name!\n", fname ));
2076                 return NT_STATUS_NOT_A_DIRECTORY;
2077         }
2078
2079         switch( create_disposition ) {
2080                 case FILE_OPEN:
2081
2082                         info = FILE_WAS_OPENED;
2083
2084                         /*
2085                          * We want to follow symlinks here.
2086                          */
2087
2088                         if (SMB_VFS_STAT(conn, fname, psbuf) != 0) {
2089                                 return map_nt_error_from_unix(errno);
2090                         }
2091
2092                         break;
2093
2094                 case FILE_CREATE:
2095
2096                         /* If directory exists error. If directory doesn't
2097                          * exist create. */
2098
2099                         status = mkdir_internal(conn,
2100                                                 fname,
2101                                                 file_attributes,
2102                                                 psbuf);
2103
2104                         if (!NT_STATUS_IS_OK(status)) {
2105                                 DEBUG(2, ("open_directory: unable to create "
2106                                           "%s. Error was %s\n", fname,
2107                                           nt_errstr(status)));
2108                                 return status;
2109                         }
2110
2111                         info = FILE_WAS_CREATED;
2112                         break;
2113
2114                 case FILE_OPEN_IF:
2115                         /*
2116                          * If directory exists open. If directory doesn't
2117                          * exist create.
2118                          */
2119
2120                         status = mkdir_internal(conn,
2121                                                 fname,
2122                                                 file_attributes,
2123                                                 psbuf);
2124
2125                         if (NT_STATUS_IS_OK(status)) {
2126                                 info = FILE_WAS_CREATED;
2127                         }
2128
2129                         if (NT_STATUS_EQUAL(status,
2130                                             NT_STATUS_OBJECT_NAME_COLLISION)) {
2131                                 info = FILE_WAS_OPENED;
2132                                 status = NT_STATUS_OK;
2133                         }
2134
2135                         break;
2136
2137                 case FILE_SUPERSEDE:
2138                 case FILE_OVERWRITE:
2139                 case FILE_OVERWRITE_IF:
2140                 default:
2141                         DEBUG(5,("open_directory: invalid create_disposition "
2142                                  "0x%x for directory %s\n",
2143                                  (unsigned int)create_disposition, fname));
2144                         return NT_STATUS_INVALID_PARAMETER;
2145         }
2146
2147         if(!S_ISDIR(psbuf->st_mode)) {
2148                 DEBUG(5,("open_directory: %s is not a directory !\n",
2149                          fname ));
2150                 return NT_STATUS_NOT_A_DIRECTORY;
2151         }
2152
2153         status = file_new(conn, &fsp);
2154         if(!NT_STATUS_IS_OK(status)) {
2155                 return status;
2156         }
2157
2158         /*
2159          * Setup the files_struct for it.
2160          */
2161
2162         fsp->mode = psbuf->st_mode;
2163         fsp->file_id = file_id_sbuf(psbuf);
2164         fsp->vuid = req ? req->vuid : UID_FIELD_INVALID;
2165         fsp->file_pid = req ? req->smbpid : 0;
2166         fsp->can_lock = False;
2167         fsp->can_read = False;
2168         fsp->can_write = False;
2169
2170         fsp->share_access = share_access;
2171         fsp->fh->private_options = create_options;
2172         fsp->access_mask = access_mask;
2173
2174         fsp->print_file = False;
2175         fsp->modified = False;
2176         fsp->oplock_type = NO_OPLOCK;
2177         fsp->sent_oplock_break = NO_BREAK_SENT;
2178         fsp->is_directory = True;
2179         fsp->is_stat = False;
2180         fsp->posix_open = (file_attributes & FILE_FLAG_POSIX_SEMANTICS) ? True : False;
2181
2182         string_set(&fsp->fsp_name,fname);
2183
2184         lck = get_share_mode_lock(NULL, fsp->file_id,
2185                                   conn->connectpath,
2186                                   fname);
2187
2188         if (lck == NULL) {
2189                 DEBUG(0, ("open_directory: Could not get share mode lock for %s\n", fname));
2190                 file_free(fsp);
2191                 return NT_STATUS_SHARING_VIOLATION;
2192         }
2193
2194         status = open_mode_check(conn, fname, lck,
2195                                 access_mask, share_access,
2196                                 create_options, &dir_existed);
2197
2198         if (!NT_STATUS_IS_OK(status)) {
2199                 TALLOC_FREE(lck);
2200                 file_free(fsp);
2201                 return status;
2202         }
2203
2204         set_share_mode(lck, fsp, current_user.ut.uid, 0, NO_OPLOCK, True);
2205
2206         /* For directories the delete on close bit at open time seems
2207            always to be honored on close... See test 19 in Samba4 BASE-DELETE. */
2208         if (create_options & FILE_DELETE_ON_CLOSE) {
2209                 status = can_set_delete_on_close(fsp, True, 0);
2210                 if (!NT_STATUS_IS_OK(status) && !NT_STATUS_EQUAL(status, NT_STATUS_DIRECTORY_NOT_EMPTY)) {
2211                         TALLOC_FREE(lck);
2212                         file_free(fsp);
2213                         return status;
2214                 }
2215
2216                 if (NT_STATUS_IS_OK(status)) {
2217                         /* Note that here we set the *inital* delete on close flag,
2218                            not the regular one. The magic gets handled in close. */
2219                         fsp->initial_delete_on_close = True;
2220                 }
2221         }
2222
2223         TALLOC_FREE(lck);
2224
2225         if (pinfo) {
2226                 *pinfo = info;
2227         }
2228
2229         conn->num_files_open++;
2230
2231         *result = fsp;
2232         return NT_STATUS_OK;
2233 }
2234
2235 NTSTATUS create_directory(connection_struct *conn, const char *directory)
2236 {
2237         NTSTATUS status;
2238         SMB_STRUCT_STAT sbuf;
2239         files_struct *fsp;
2240
2241         SET_STAT_INVALID(sbuf);
2242
2243         status = open_directory(conn, NULL, directory, &sbuf,
2244                                 FILE_READ_ATTRIBUTES, /* Just a stat open */
2245                                 FILE_SHARE_NONE, /* Ignored for stat opens */
2246                                 FILE_CREATE,
2247                                 0,
2248                                 FILE_ATTRIBUTE_DIRECTORY,
2249                                 NULL,
2250                                 &fsp);
2251
2252         if (NT_STATUS_IS_OK(status)) {
2253                 close_file(fsp, NORMAL_CLOSE);
2254         }
2255
2256         return status;
2257 }
2258
2259 /****************************************************************************
2260  Open a pseudo-file (no locking checks - a 'stat' open).
2261 ****************************************************************************/
2262
2263 NTSTATUS open_file_stat(connection_struct *conn, struct smb_request *req,
2264                         const char *fname, SMB_STRUCT_STAT *psbuf,
2265                         files_struct **result)
2266 {
2267         files_struct *fsp = NULL;
2268         NTSTATUS status;
2269
2270         if (!VALID_STAT(*psbuf)) {
2271                 return NT_STATUS_INVALID_PARAMETER;
2272         }
2273
2274         /* Can't 'stat' open directories. */
2275         if(S_ISDIR(psbuf->st_mode)) {
2276                 return NT_STATUS_FILE_IS_A_DIRECTORY;
2277         }
2278
2279         status = file_new(conn, &fsp);
2280         if(!NT_STATUS_IS_OK(status)) {
2281                 return status;
2282         }
2283
2284         DEBUG(5,("open_file_stat: 'opening' file %s\n", fname));
2285
2286         /*
2287          * Setup the files_struct for it.
2288          */
2289
2290         fsp->mode = psbuf->st_mode;
2291         fsp->file_id = file_id_sbuf(psbuf);
2292         fsp->vuid = req ? req->vuid : UID_FIELD_INVALID;
2293         fsp->file_pid = req ? req->smbpid : 0;
2294         fsp->can_lock = False;
2295         fsp->can_read = False;
2296         fsp->can_write = False;
2297         fsp->print_file = False;
2298         fsp->modified = False;
2299         fsp->oplock_type = NO_OPLOCK;
2300         fsp->sent_oplock_break = NO_BREAK_SENT;
2301         fsp->is_directory = False;
2302         fsp->is_stat = True;
2303         string_set(&fsp->fsp_name,fname);
2304
2305         conn->num_files_open++;
2306
2307         *result = fsp;
2308         return NT_STATUS_OK;
2309 }
2310
2311 /****************************************************************************
2312  Receive notification that one of our open files has been renamed by another
2313  smbd process.
2314 ****************************************************************************/
2315
2316 void msg_file_was_renamed(struct messaging_context *msg,
2317                           void *private_data,
2318                           uint32_t msg_type,
2319                           struct server_id server_id,
2320                           DATA_BLOB *data)
2321 {
2322         files_struct *fsp;
2323         char *frm = (char *)data->data;
2324         struct file_id id;
2325         const char *sharepath;
2326         const char *newname;
2327         size_t sp_len;
2328
2329         if (data->data == NULL
2330             || data->length < MSG_FILE_RENAMED_MIN_SIZE + 2) {
2331                 DEBUG(0, ("msg_file_was_renamed: Got invalid msg len %d\n",
2332                           (int)data->length));
2333                 return;
2334         }
2335
2336         /* Unpack the message. */
2337         pull_file_id_16(frm, &id);
2338         sharepath = &frm[16];
2339         newname = sharepath + strlen(sharepath) + 1;
2340         sp_len = strlen(sharepath);
2341
2342         DEBUG(10,("msg_file_was_renamed: Got rename message for sharepath %s, new name %s, "
2343                 "file_id %s\n",
2344                   sharepath, newname, file_id_static_string(&id)));
2345
2346         for(fsp = file_find_di_first(id); fsp; fsp = file_find_di_next(fsp)) {
2347                 if (memcmp(fsp->conn->connectpath, sharepath, sp_len) == 0) {
2348                         DEBUG(10,("msg_file_was_renamed: renaming file fnum %d from %s -> %s\n",
2349                                 fsp->fnum, fsp->fsp_name, newname ));
2350                         string_set(&fsp->fsp_name, newname);
2351                 } else {
2352                         /* TODO. JRA. */
2353                         /* Now we have the complete path we can work out if this is
2354                            actually within this share and adjust newname accordingly. */
2355                         DEBUG(10,("msg_file_was_renamed: share mismatch (sharepath %s "
2356                                 "not sharepath %s) "
2357                                 "fnum %d from %s -> %s\n",
2358                                 fsp->conn->connectpath,
2359                                 sharepath,
2360                                 fsp->fnum,
2361                                 fsp->fsp_name,
2362                                 newname ));
2363                 }
2364         }
2365 }