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