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