source3/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 = vfs_file_id_from_sbuf(conn, 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                        struct smb_request *req,
 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 == req->mid)) {
 786                         DEBUG(0, ("Trying to defer an already deferred "
 787                                   "request: mid=%d, exiting\n", req->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)req->mid));
 799
 800         if (!push_deferred_smb_message(req, request_time, timeout,
 801                                        (char *)state, sizeof(*state))) {
 802                 exit_server("push_deferred_smb_message failed");
 803         }
 804         add_deferred_open(lck, req->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(req->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                                 struct smb_request *req)
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, req, &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(talloc_tos(), 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 = vfs_file_id_from_sbuf(conn, 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 = vfs_file_id_from_sbuf(conn, 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);
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, req);
1472                                 TALLOC_FREE(lck);
1473                                 file_free(fsp);
1474                                 return NT_STATUS_SHARING_VIOLATION;
1475                         }
1476                 }
1477
1478                 if (NT_STATUS_EQUAL(status, NT_STATUS_DELETE_PENDING)) {
1479                         /* DELETE_PENDING is not deferred for a second */
1480                         TALLOC_FREE(lck);
1481                         file_free(fsp);
1482                         return status;
1483                 }
1484
1485                 if (!NT_STATUS_IS_OK(status)) {
1486                         uint32 can_access_mask;
1487                         BOOL can_access = True;
1488
1489                         SMB_ASSERT(NT_STATUS_EQUAL(status, NT_STATUS_SHARING_VIOLATION));
1490
1491                         /* Check if this can be done with the deny_dos and fcb
1492                          * calls. */
1493                         if (create_options &
1494                             (NTCREATEX_OPTIONS_PRIVATE_DENY_DOS|
1495                              NTCREATEX_OPTIONS_PRIVATE_DENY_FCB)) {
1496                                 files_struct *fsp_dup;
1497
1498                                 if (req == NULL) {
1499                                         DEBUG(0, ("DOS open without an SMB "
1500                                                   "request!\n"));
1501                                         TALLOC_FREE(lck);
1502                                         file_free(fsp);
1503                                         return NT_STATUS_INTERNAL_ERROR;
1504                                 }
1505
1506                                 /* Use the client requested access mask here,
1507                                  * not the one we open with. */
1508                                 fsp_dup = fcb_or_dos_open(conn, fname, id,
1509                                                           req->smbpid,
1510                                                           req->vuid,
1511                                                           access_mask,
1512                                                           share_access,
1513                                                           create_options);
1514
1515                                 if (fsp_dup) {
1516                                         TALLOC_FREE(lck);
1517                                         file_free(fsp);
1518                                         if (pinfo) {
1519                                                 *pinfo = FILE_WAS_OPENED;
1520                                         }
1521                                         conn->num_files_open++;
1522                                         *result = fsp_dup;
1523                                         return NT_STATUS_OK;
1524                                 }
1525                         }
1526
1527                         /*
1528                          * This next line is a subtlety we need for
1529                          * MS-Access. If a file open will fail due to share
1530                          * permissions and also for security (access) reasons,
1531                          * we need to return the access failed error, not the
1532                          * share error. We can't open the file due to kernel
1533                          * oplock deadlock (it's possible we failed above on
1534                          * the open_mode_check()) so use a userspace check.
1535                          */
1536
1537                         if (flags & O_RDWR) {
1538                                 can_access_mask = FILE_READ_DATA|FILE_WRITE_DATA;
1539                         } else if (flags & O_WRONLY) {
1540                                 can_access_mask = FILE_WRITE_DATA;
1541                         } else {
1542                                 can_access_mask = FILE_READ_DATA;
1543                         }
1544
1545                         if (((can_access_mask & FILE_WRITE_DATA) && !CAN_WRITE(conn)) ||
1546                             !can_access_file(conn,fname,psbuf,can_access_mask)) {
1547                                 can_access = False;
1548                         }
1549
1550                         /*
1551                          * If we're returning a share violation, ensure we
1552                          * cope with the braindead 1 second delay.
1553                          */
1554
1555                         if (!(oplock_request & INTERNAL_OPEN_ONLY) &&
1556                             lp_defer_sharing_violations()) {
1557                                 struct timeval timeout;
1558                                 struct deferred_open_record state;
1559                                 int timeout_usecs;
1560
1561                                 /* this is a hack to speed up torture tests
1562                                    in 'make test' */
1563                                 timeout_usecs = lp_parm_int(SNUM(conn),
1564                                                             "smbd","sharedelay",
1565                                                             SHARING_VIOLATION_USEC_WAIT);
1566
1567                                 /* This is a relative time, added to the absolute
1568                                    request_time value to get the absolute timeout time.
1569                                    Note that if this is the second or greater time we enter
1570                                    this codepath for this particular request mid then
1571                                    request_time is left as the absolute time of the *first*
1572                                    time this request mid was processed. This is what allows
1573                                    the request to eventually time out. */
1574
1575                                 timeout = timeval_set(0, timeout_usecs);
1576
1577                                 /* Nothing actually uses state.delayed_for_oplocks
1578                                    but it's handy to differentiate in debug messages
1579                                    between a 30 second delay due to oplock break, and
1580                                    a 1 second delay for share mode conflicts. */
1581
1582                                 state.delayed_for_oplocks = False;
1583                                 state.id = id;
1584
1585                                 if ((req != NULL)
1586                                     && !request_timed_out(request_time,
1587                                                           timeout)) {
1588                                         defer_open(lck, request_time, timeout,
1589                                                    req, &state);
1590                                 }
1591                         }
1592
1593                         TALLOC_FREE(lck);
1594                         if (can_access) {
1595                                 /*
1596                                  * We have detected a sharing violation here
1597                                  * so return the correct error code
1598                                  */
1599                                 status = NT_STATUS_SHARING_VIOLATION;
1600                         } else {
1601                                 status = NT_STATUS_ACCESS_DENIED;
1602                         }
1603                         file_free(fsp);
1604                         return status;
1605                 }
1606
1607                 /*
1608                  * We exit this block with the share entry *locked*.....
1609                  */
1610         }
1611
1612         SMB_ASSERT(!file_existed || (lck != NULL));
1613
1614         /*
1615          * Ensure we pay attention to default ACLs on directories if required.
1616          */
1617
1618         if ((flags2 & O_CREAT) && lp_inherit_acls(SNUM(conn)) &&
1619             (def_acl = directory_has_default_acl(conn, parent_dir))) {
1620                 unx_mode = 0777;
1621         }
1622
1623         DEBUG(4,("calling open_file with flags=0x%X flags2=0x%X mode=0%o, "
1624                 "access_mask = 0x%x, open_access_mask = 0x%x\n",
1625                  (unsigned int)flags, (unsigned int)flags2,
1626                  (unsigned int)unx_mode, (unsigned int)access_mask,
1627                  (unsigned int)open_access_mask));
1628
1629         /*
1630          * open_file strips any O_TRUNC flags itself.
1631          */
1632
1633         fsp_open = open_file(fsp, conn, req, parent_dir, newname, fname, psbuf,
1634                              flags|flags2, unx_mode, access_mask,
1635                              open_access_mask);
1636
1637         if (!NT_STATUS_IS_OK(fsp_open)) {
1638                 if (lck != NULL) {
1639                         TALLOC_FREE(lck);
1640                 }
1641                 file_free(fsp);
1642                 return fsp_open;
1643         }
1644
1645         if (!file_existed) {
1646
1647                 /*
1648                  * Deal with the race condition where two smbd's detect the
1649                  * file doesn't exist and do the create at the same time. One
1650                  * of them will win and set a share mode, the other (ie. this
1651                  * one) should check if the requested share mode for this
1652                  * create is allowed.
1653                  */
1654
1655                 /*
1656                  * Now the file exists and fsp is successfully opened,
1657                  * fsp->dev and fsp->inode are valid and should replace the
1658                  * dev=0,inode=0 from a non existent file. Spotted by
1659                  * Nadav Danieli <nadavd@exanet.com>. JRA.
1660                  */
1661
1662                 id = fsp->file_id;
1663
1664                 lck = get_share_mode_lock(NULL, id,
1665                                           conn->connectpath,
1666                                           fname);
1667
1668                 if (lck == NULL) {
1669                         DEBUG(0, ("open_file_ntcreate: Could not get share "
1670                                   "mode lock for %s\n", fname));
1671                         fd_close(conn, fsp);
1672                         file_free(fsp);
1673                         return NT_STATUS_SHARING_VIOLATION;
1674                 }
1675
1676                 /* First pass - send break only on batch oplocks. */
1677                 if ((req != NULL)
1678                     && delay_for_oplocks(lck, fsp, req->mid, 1,
1679                                          oplock_request)) {
1680                         schedule_defer_open(lck, request_time, req);
1681                         TALLOC_FREE(lck);
1682                         fd_close(conn, fsp);
1683                         file_free(fsp);
1684                         return NT_STATUS_SHARING_VIOLATION;
1685                 }
1686
1687                 status = open_mode_check(conn, fname, lck,
1688                                          access_mask, share_access,
1689                                          create_options, &file_existed);
1690
1691                 if (NT_STATUS_IS_OK(status)) {
1692                         /* We might be going to allow this open. Check oplock
1693                          * status again. */
1694                         /* Second pass - send break for both batch or
1695                          * exclusive oplocks. */
1696                         if ((req != NULL)
1697                             && delay_for_oplocks(lck, fsp, req->mid, 2,
1698                                                  oplock_request)) {
1699                                 schedule_defer_open(lck, request_time, req);
1700                                 TALLOC_FREE(lck);
1701                                 fd_close(conn, fsp);
1702                                 file_free(fsp);
1703                                 return NT_STATUS_SHARING_VIOLATION;
1704                         }
1705                 }
1706
1707                 if (!NT_STATUS_IS_OK(status)) {
1708                         struct deferred_open_record state;
1709
1710                         fd_close(conn, fsp);
1711                         file_free(fsp);
1712
1713                         state.delayed_for_oplocks = False;
1714                         state.id = id;
1715
1716                         /* Do it all over again immediately. In the second
1717                          * round we will find that the file existed and handle
1718                          * the DELETE_PENDING and FCB cases correctly. No need
1719                          * to duplicate the code here. Essentially this is a
1720                          * "goto top of this function", but don't tell
1721                          * anybody... */
1722
1723                         if (req != NULL) {
1724                                 defer_open(lck, request_time, timeval_zero(),
1725                                            req, &state);
1726                         }
1727                         TALLOC_FREE(lck);
1728                         return status;
1729                 }
1730
1731                 /*
1732                  * We exit this block with the share entry *locked*.....
1733                  */
1734
1735         }
1736
1737         SMB_ASSERT(lck != NULL);
1738
1739         /* note that we ignore failure for the following. It is
1740            basically a hack for NFS, and NFS will never set one of
1741            these only read them. Nobody but Samba can ever set a deny
1742            mode and we have already checked our more authoritative
1743            locking database for permission to set this deny mode. If
1744            the kernel refuses the operations then the kernel is wrong.
1745            note that GPFS supports it as well - jmcd */
1746
1747         ret_flock = SMB_VFS_KERNEL_FLOCK(fsp, fsp->fh->fd, share_access);
1748         if(ret_flock == -1 ){
1749
1750                 TALLOC_FREE(lck);
1751                 fd_close(conn, fsp);
1752                 file_free(fsp);
1753
1754                 return NT_STATUS_SHARING_VIOLATION;
1755         }
1756
1757         /*
1758          * At this point onwards, we can guarentee that the share entry
1759          * is locked, whether we created the file or not, and that the
1760          * deny mode is compatible with all current opens.
1761          */
1762
1763         /*
1764          * If requested, truncate the file.
1765          */
1766
1767         if (flags2&O_TRUNC) {
1768                 /*
1769                  * We are modifing the file after open - update the stat
1770                  * struct..
1771                  */
1772                 if ((SMB_VFS_FTRUNCATE(fsp,fsp->fh->fd,0) == -1) ||
1773                     (SMB_VFS_FSTAT(fsp,fsp->fh->fd,psbuf)==-1)) {
1774                         status = map_nt_error_from_unix(errno);
1775                         TALLOC_FREE(lck);
1776                         fd_close(conn,fsp);
1777                         file_free(fsp);
1778                         return status;
1779                 }
1780         }
1781
1782         /* Record the options we were opened with. */
1783         fsp->share_access = share_access;
1784         fsp->fh->private_options = create_options;
1785         fsp->access_mask = access_mask;
1786
1787         if (file_existed) {
1788                 /* stat opens on existing files don't get oplocks. */
1789                 if (is_stat_open(open_access_mask)) {
1790                         fsp->oplock_type = NO_OPLOCK;
1791                 }
1792
1793                 if (!(flags2 & O_TRUNC)) {
1794                         info = FILE_WAS_OPENED;
1795                 } else {
1796                         info = FILE_WAS_OVERWRITTEN;
1797                 }
1798         } else {
1799                 info = FILE_WAS_CREATED;
1800         }
1801
1802         if (pinfo) {
1803                 *pinfo = info;
1804         }
1805
1806         /*
1807          * Setup the oplock info in both the shared memory and
1808          * file structs.
1809          */
1810
1811         if ((fsp->oplock_type != NO_OPLOCK) &&
1812             (fsp->oplock_type != FAKE_LEVEL_II_OPLOCK)) {
1813                 if (!set_file_oplock(fsp, fsp->oplock_type)) {
1814                         /* Could not get the kernel oplock */
1815                         fsp->oplock_type = NO_OPLOCK;
1816                 }
1817         }
1818
1819         if (info == FILE_WAS_OVERWRITTEN || info == FILE_WAS_CREATED || info == FILE_WAS_SUPERSEDED) {
1820                 new_file_created = True;
1821         }
1822
1823         set_share_mode(lck, fsp, current_user.ut.uid, 0, fsp->oplock_type, new_file_created);
1824
1825         /* Handle strange delete on close create semantics. */
1826         if ((create_options & FILE_DELETE_ON_CLOSE) && can_set_initial_delete_on_close(lck)) {
1827                 status = can_set_delete_on_close(fsp, True, new_dos_attributes);
1828
1829                 if (!NT_STATUS_IS_OK(status)) {
1830                         /* Remember to delete the mode we just added. */
1831                         del_share_mode(lck, fsp);
1832                         TALLOC_FREE(lck);
1833                         fd_close(conn,fsp);
1834                         file_free(fsp);
1835                         return status;
1836                 }
1837                 /* Note that here we set the *inital* delete on close flag,
1838                    not the regular one. The magic gets handled in close. */
1839                 fsp->initial_delete_on_close = True;
1840         }
1841
1842         if (new_file_created) {
1843                 /* Files should be initially set as archive */
1844                 if (lp_map_archive(SNUM(conn)) ||
1845                     lp_store_dos_attributes(SNUM(conn))) {
1846                         if (!posix_open) {
1847                                 file_set_dosmode(conn, fname,
1848                                          new_dos_attributes | aARCH, NULL,
1849                                          parent_dir);
1850                         }
1851                 }
1852         }
1853
1854         /*
1855          * Take care of inherited ACLs on created files - if default ACL not
1856          * selected.
1857          */
1858
1859         if (!posix_open && !file_existed && !def_acl) {
1860
1861                 int saved_errno = errno; /* We might get ENOSYS in the next
1862                                           * call.. */
1863
1864                 if (SMB_VFS_FCHMOD_ACL(fsp, fsp->fh->fd, unx_mode) == -1 &&
1865                     errno == ENOSYS) {
1866                         errno = saved_errno; /* Ignore ENOSYS */
1867                 }
1868
1869         } else if (new_unx_mode) {
1870
1871                 int ret = -1;
1872
1873                 /* Attributes need changing. File already existed. */
1874
1875                 {
1876                         int saved_errno = errno; /* We might get ENOSYS in the
1877                                                   * next call.. */
1878                         ret = SMB_VFS_FCHMOD_ACL(fsp, fsp->fh->fd,
1879                                                  new_unx_mode);
1880
1881                         if (ret == -1 && errno == ENOSYS) {
1882                                 errno = saved_errno; /* Ignore ENOSYS */
1883                         } else {
1884                                 DEBUG(5, ("open_file_ntcreate: reset "
1885                                           "attributes of file %s to 0%o\n",
1886                                           fname, (unsigned int)new_unx_mode));
1887                                 ret = 0; /* Don't do the fchmod below. */
1888                         }
1889                 }
1890
1891                 if ((ret == -1) &&
1892                     (SMB_VFS_FCHMOD(fsp, fsp->fh->fd, new_unx_mode) == -1))
1893                         DEBUG(5, ("open_file_ntcreate: failed to reset "
1894                                   "attributes of file %s to 0%o\n",
1895                                   fname, (unsigned int)new_unx_mode));
1896         }
1897
1898         /* If this is a successful open, we must remove any deferred open
1899          * records. */
1900         if (req != NULL) {
1901                 del_deferred_open_entry(lck, req->mid);
1902         }
1903         TALLOC_FREE(lck);
1904
1905         conn->num_files_open++;
1906
1907         *result = fsp;
1908         return NT_STATUS_OK;
1909 }
1910
1911 /****************************************************************************
1912  Open a file for for write to ensure that we can fchmod it.
1913 ****************************************************************************/
1914
1915 NTSTATUS open_file_fchmod(connection_struct *conn, const char *fname,
1916                           SMB_STRUCT_STAT *psbuf, files_struct **result)
1917 {
1918         files_struct *fsp = NULL;
1919         NTSTATUS status;
1920
1921         if (!VALID_STAT(*psbuf)) {
1922                 return NT_STATUS_INVALID_PARAMETER;
1923         }
1924
1925         status = file_new(conn, &fsp);
1926         if(!NT_STATUS_IS_OK(status)) {
1927                 return status;
1928         }
1929
1930         /* note! we must use a non-zero desired access or we don't get
1931            a real file descriptor. Oh what a twisted web we weave. */
1932         status = open_file(fsp, conn, NULL, NULL, NULL, fname, psbuf, O_WRONLY,
1933                            0, FILE_WRITE_DATA, FILE_WRITE_DATA);
1934
1935         /*
1936          * This is not a user visible file open.
1937          * Don't set a share mode and don't increment
1938          * the conn->num_files_open.
1939          */
1940
1941         if (!NT_STATUS_IS_OK(status)) {
1942                 file_free(fsp);
1943                 return status;
1944         }
1945
1946         *result = fsp;
1947         return NT_STATUS_OK;
1948 }
1949
1950 /****************************************************************************
1951  Close the fchmod file fd - ensure no locks are lost.
1952 ****************************************************************************/
1953
1954 NTSTATUS close_file_fchmod(files_struct *fsp)
1955 {
1956         NTSTATUS status = fd_close(fsp->conn, fsp);
1957         file_free(fsp);
1958         return status;
1959 }
1960
1961 static NTSTATUS mkdir_internal(connection_struct *conn,
1962                                 const char *name,
1963                                 uint32 file_attributes,
1964                                 SMB_STRUCT_STAT *psbuf)
1965 {
1966         mode_t mode;
1967         char *parent_dir;
1968         const char *dirname;
1969         NTSTATUS status;
1970
1971         if(!CAN_WRITE(conn)) {
1972                 DEBUG(5,("mkdir_internal: failing create on read-only share "
1973                          "%s\n", lp_servicename(SNUM(conn))));
1974                 return NT_STATUS_ACCESS_DENIED;
1975         }
1976
1977         status = check_name(conn, name);
1978         if (!NT_STATUS_IS_OK(status)) {
1979                 return status;
1980         }
1981
1982         if (!parent_dirname_talloc(talloc_tos(), name, &parent_dir,
1983                                    &dirname)) {
1984                 return NT_STATUS_NO_MEMORY;
1985         }
1986
1987         if (file_attributes & FILE_FLAG_POSIX_SEMANTICS) {
1988                 mode = (mode_t)(file_attributes & ~FILE_FLAG_POSIX_SEMANTICS);
1989         } else {
1990                 mode = unix_mode(conn, aDIR, name, parent_dir);
1991         }
1992
1993         if (SMB_VFS_MKDIR(conn, name, mode) != 0) {
1994                 return map_nt_error_from_unix(errno);
1995         }
1996
1997         /* Ensure we're checking for a symlink here.... */
1998         /* We don't want to get caught by a symlink racer. */
1999
2000         if (SMB_VFS_LSTAT(conn, name, psbuf) == -1) {
2001                 DEBUG(2, ("Could not stat directory '%s' just created: %s\n",
2002                           name, strerror(errno)));
2003                 return map_nt_error_from_unix(errno);
2004         }
2005
2006         if (!S_ISDIR(psbuf->st_mode)) {
2007                 DEBUG(0, ("Directory just '%s' created is not a directory\n",
2008                           name));
2009                 return NT_STATUS_ACCESS_DENIED;
2010         }
2011
2012         if (lp_inherit_perms(SNUM(conn))) {
2013                 inherit_access_acl(conn, parent_dir, name, mode);
2014         }
2015
2016         if (!(file_attributes & FILE_FLAG_POSIX_SEMANTICS)) {
2017                 /*
2018                  * Check if high bits should have been set,
2019                  * then (if bits are missing): add them.
2020                  * Consider bits automagically set by UNIX, i.e. SGID bit from parent
2021                  * dir.
2022                  */
2023                 if (mode & ~(S_IRWXU|S_IRWXG|S_IRWXO) && (mode & ~psbuf->st_mode)) {
2024                         SMB_VFS_CHMOD(conn, name,
2025                                       psbuf->st_mode | (mode & ~psbuf->st_mode));
2026                 }
2027         }
2028
2029         /* Change the owner if required. */
2030         if (lp_inherit_owner(SNUM(conn))) {
2031                 change_dir_owner_to_parent(conn, parent_dir, name, psbuf);
2032         }
2033
2034         notify_fname(conn, NOTIFY_ACTION_ADDED, FILE_NOTIFY_CHANGE_DIR_NAME,
2035                      name);
2036
2037         return NT_STATUS_OK;
2038 }
2039
2040 /****************************************************************************
2041  Open a directory from an NT SMB call.
2042 ****************************************************************************/
2043
2044 NTSTATUS open_directory(connection_struct *conn,
2045                         struct smb_request *req,
2046                         const char *fname,
2047                         SMB_STRUCT_STAT *psbuf,
2048                         uint32 access_mask,
2049                         uint32 share_access,
2050                         uint32 create_disposition,
2051                         uint32 create_options,
2052                         uint32 file_attributes,
2053                         int *pinfo,
2054                         files_struct **result)
2055 {
2056         files_struct *fsp = NULL;
2057         BOOL dir_existed = VALID_STAT(*psbuf) ? True : False;
2058         struct share_mode_lock *lck = NULL;
2059         NTSTATUS status;
2060         int info = 0;
2061
2062         DEBUG(5,("open_directory: opening directory %s, access_mask = 0x%x, "
2063                  "share_access = 0x%x create_options = 0x%x, "
2064                  "create_disposition = 0x%x, file_attributes = 0x%x\n",
2065                  fname,
2066                  (unsigned int)access_mask,
2067                  (unsigned int)share_access,
2068                  (unsigned int)create_options,
2069                  (unsigned int)create_disposition,
2070                  (unsigned int)file_attributes));
2071
2072         if (is_ntfs_stream_name(fname)) {
2073                 DEBUG(0,("open_directory: %s is a stream name!\n", fname ));
2074                 return NT_STATUS_NOT_A_DIRECTORY;
2075         }
2076
2077         switch( create_disposition ) {
2078                 case FILE_OPEN:
2079
2080                         info = FILE_WAS_OPENED;
2081
2082                         /*
2083                          * We want to follow symlinks here.
2084                          */
2085
2086                         if (SMB_VFS_STAT(conn, fname, psbuf) != 0) {
2087                                 return map_nt_error_from_unix(errno);
2088                         }
2089
2090                         break;
2091
2092                 case FILE_CREATE:
2093
2094                         /* If directory exists error. If directory doesn't
2095                          * exist create. */
2096
2097                         status = mkdir_internal(conn,
2098                                                 fname,
2099                                                 file_attributes,
2100                                                 psbuf);
2101
2102                         if (!NT_STATUS_IS_OK(status)) {
2103                                 DEBUG(2, ("open_directory: unable to create "
2104                                           "%s. Error was %s\n", fname,
2105                                           nt_errstr(status)));
2106                                 return status;
2107                         }
2108
2109                         info = FILE_WAS_CREATED;
2110                         break;
2111
2112                 case FILE_OPEN_IF:
2113                         /*
2114                          * If directory exists open. If directory doesn't
2115                          * exist create.
2116                          */
2117
2118                         status = mkdir_internal(conn,
2119                                                 fname,
2120                                                 file_attributes,
2121                                                 psbuf);
2122
2123                         if (NT_STATUS_IS_OK(status)) {
2124                                 info = FILE_WAS_CREATED;
2125                         }
2126
2127                         if (NT_STATUS_EQUAL(status,
2128                                             NT_STATUS_OBJECT_NAME_COLLISION)) {
2129                                 info = FILE_WAS_OPENED;
2130                                 status = NT_STATUS_OK;
2131                         }
2132
2133                         break;
2134
2135                 case FILE_SUPERSEDE:
2136                 case FILE_OVERWRITE:
2137                 case FILE_OVERWRITE_IF:
2138                 default:
2139                         DEBUG(5,("open_directory: invalid create_disposition "
2140                                  "0x%x for directory %s\n",
2141                                  (unsigned int)create_disposition, fname));
2142                         return NT_STATUS_INVALID_PARAMETER;
2143         }
2144
2145         if(!S_ISDIR(psbuf->st_mode)) {
2146                 DEBUG(5,("open_directory: %s is not a directory !\n",
2147                          fname ));
2148                 return NT_STATUS_NOT_A_DIRECTORY;
2149         }
2150
2151         status = file_new(conn, &fsp);
2152         if(!NT_STATUS_IS_OK(status)) {
2153                 return status;
2154         }
2155
2156         /*
2157          * Setup the files_struct for it.
2158          */
2159
2160         fsp->mode = psbuf->st_mode;
2161         fsp->file_id = vfs_file_id_from_sbuf(conn, psbuf);
2162         fsp->vuid = req ? req->vuid : UID_FIELD_INVALID;
2163         fsp->file_pid = req ? req->smbpid : 0;
2164         fsp->can_lock = False;
2165         fsp->can_read = False;
2166         fsp->can_write = False;
2167
2168         fsp->share_access = share_access;
2169         fsp->fh->private_options = create_options;
2170         fsp->access_mask = access_mask;
2171
2172         fsp->print_file = False;
2173         fsp->modified = False;
2174         fsp->oplock_type = NO_OPLOCK;
2175         fsp->sent_oplock_break = NO_BREAK_SENT;
2176         fsp->is_directory = True;
2177         fsp->is_stat = False;
2178         fsp->posix_open = (file_attributes & FILE_FLAG_POSIX_SEMANTICS) ? True : False;
2179
2180         string_set(&fsp->fsp_name,fname);
2181
2182         lck = get_share_mode_lock(NULL, fsp->file_id,
2183                                   conn->connectpath,
2184                                   fname);
2185
2186         if (lck == NULL) {
2187                 DEBUG(0, ("open_directory: Could not get share mode lock for %s\n", fname));
2188                 file_free(fsp);
2189                 return NT_STATUS_SHARING_VIOLATION;
2190         }
2191
2192         status = open_mode_check(conn, fname, lck,
2193                                 access_mask, share_access,
2194                                 create_options, &dir_existed);
2195
2196         if (!NT_STATUS_IS_OK(status)) {
2197                 TALLOC_FREE(lck);
2198                 file_free(fsp);
2199                 return status;
2200         }
2201
2202         set_share_mode(lck, fsp, current_user.ut.uid, 0, NO_OPLOCK, True);
2203
2204         /* For directories the delete on close bit at open time seems
2205            always to be honored on close... See test 19 in Samba4 BASE-DELETE. */
2206         if (create_options & FILE_DELETE_ON_CLOSE) {
2207                 status = can_set_delete_on_close(fsp, True, 0);
2208                 if (!NT_STATUS_IS_OK(status) && !NT_STATUS_EQUAL(status, NT_STATUS_DIRECTORY_NOT_EMPTY)) {
2209                         TALLOC_FREE(lck);
2210                         file_free(fsp);
2211                         return status;
2212                 }
2213
2214                 if (NT_STATUS_IS_OK(status)) {
2215                         /* Note that here we set the *inital* delete on close flag,
2216                            not the regular one. The magic gets handled in close. */
2217                         fsp->initial_delete_on_close = True;
2218                 }
2219         }
2220
2221         TALLOC_FREE(lck);
2222
2223         if (pinfo) {
2224                 *pinfo = info;
2225         }
2226
2227         conn->num_files_open++;
2228
2229         *result = fsp;
2230         return NT_STATUS_OK;
2231 }
2232
2233 NTSTATUS create_directory(connection_struct *conn, const char *directory)
2234 {
2235         NTSTATUS status;
2236         SMB_STRUCT_STAT sbuf;
2237         files_struct *fsp;
2238
2239         SET_STAT_INVALID(sbuf);
2240
2241         status = open_directory(conn, NULL, directory, &sbuf,
2242                                 FILE_READ_ATTRIBUTES, /* Just a stat open */
2243                                 FILE_SHARE_NONE, /* Ignored for stat opens */
2244                                 FILE_CREATE,
2245                                 0,
2246                                 FILE_ATTRIBUTE_DIRECTORY,
2247                                 NULL,
2248                                 &fsp);
2249
2250         if (NT_STATUS_IS_OK(status)) {
2251                 close_file(fsp, NORMAL_CLOSE);
2252         }
2253
2254         return status;
2255 }
2256
2257 /****************************************************************************
2258  Open a pseudo-file (no locking checks - a 'stat' open).
2259 ****************************************************************************/
2260
2261 NTSTATUS open_file_stat(connection_struct *conn, struct smb_request *req,
2262                         const char *fname, SMB_STRUCT_STAT *psbuf,
2263                         files_struct **result)
2264 {
2265         files_struct *fsp = NULL;
2266         NTSTATUS status;
2267
2268         if (!VALID_STAT(*psbuf)) {
2269                 return NT_STATUS_INVALID_PARAMETER;
2270         }
2271
2272         /* Can't 'stat' open directories. */
2273         if(S_ISDIR(psbuf->st_mode)) {
2274                 return NT_STATUS_FILE_IS_A_DIRECTORY;
2275         }
2276
2277         status = file_new(conn, &fsp);
2278         if(!NT_STATUS_IS_OK(status)) {
2279                 return status;
2280         }
2281
2282         DEBUG(5,("open_file_stat: 'opening' file %s\n", fname));
2283
2284         /*
2285          * Setup the files_struct for it.
2286          */
2287
2288         fsp->mode = psbuf->st_mode;
2289         fsp->file_id = vfs_file_id_from_sbuf(conn, psbuf);
2290         fsp->vuid = req ? req->vuid : UID_FIELD_INVALID;
2291         fsp->file_pid = req ? req->smbpid : 0;
2292         fsp->can_lock = False;
2293         fsp->can_read = False;
2294         fsp->can_write = False;
2295         fsp->print_file = False;
2296         fsp->modified = False;
2297         fsp->oplock_type = NO_OPLOCK;
2298         fsp->sent_oplock_break = NO_BREAK_SENT;
2299         fsp->is_directory = False;
2300         fsp->is_stat = True;
2301         string_set(&fsp->fsp_name,fname);
2302
2303         conn->num_files_open++;
2304
2305         *result = fsp;
2306         return NT_STATUS_OK;
2307 }
2308
2309 /****************************************************************************
2310  Receive notification that one of our open files has been renamed by another
2311  smbd process.
2312 ****************************************************************************/
2313
2314 void msg_file_was_renamed(struct messaging_context *msg,
2315                           void *private_data,
2316                           uint32_t msg_type,
2317                           struct server_id server_id,
2318                           DATA_BLOB *data)
2319 {
2320         files_struct *fsp;
2321         char *frm = (char *)data->data;
2322         struct file_id id;
2323         const char *sharepath;
2324         const char *newname;
2325         size_t sp_len;
2326
2327         if (data->data == NULL
2328             || data->length < MSG_FILE_RENAMED_MIN_SIZE + 2) {
2329                 DEBUG(0, ("msg_file_was_renamed: Got invalid msg len %d\n",
2330                           (int)data->length));
2331                 return;
2332         }
2333
2334         /* Unpack the message. */
2335         pull_file_id_16(frm, &id);
2336         sharepath = &frm[16];
2337         newname = sharepath + strlen(sharepath) + 1;
2338         sp_len = strlen(sharepath);
2339
2340         DEBUG(10,("msg_file_was_renamed: Got rename message for sharepath %s, new name %s, "
2341                 "file_id %s\n",
2342                   sharepath, newname, file_id_static_string(&id)));
2343
2344         for(fsp = file_find_di_first(id); fsp; fsp = file_find_di_next(fsp)) {
2345                 if (memcmp(fsp->conn->connectpath, sharepath, sp_len) == 0) {
2346                         DEBUG(10,("msg_file_was_renamed: renaming file fnum %d from %s -> %s\n",
2347                                 fsp->fnum, fsp->fsp_name, newname ));
2348                         string_set(&fsp->fsp_name, newname);
2349                 } else {
2350                         /* TODO. JRA. */
2351                         /* Now we have the complete path we can work out if this is
2352                            actually within this share and adjust newname accordingly. */
2353                         DEBUG(10,("msg_file_was_renamed: share mismatch (sharepath %s "
2354                                 "not sharepath %s) "
2355                                 "fnum %d from %s -> %s\n",
2356                                 fsp->conn->connectpath,
2357                                 sharepath,
2358                                 fsp->fnum,
2359                                 fsp->fsp_name,
2360                                 newname ));
2361                 }
2362         }
2363 }