source/smbd/open.c

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