source3/smbd/open.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    file opening and share modes
   4    Copyright (C) Andrew Tridgell 1992-1998
   5    Copyright (C) Jeremy Allison 2001-2004
   6    Copyright (C) Volker Lendecke 2005
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21 */
  22
  23 #include "includes.h"
  24
  25 extern struct generic_mapping file_generic_mapping;
  26 extern struct current_user current_user;
  27 extern userdom_struct current_user_info;
  28 extern uint16 global_smbpid;
  29 extern BOOL global_client_failed_oplock_break;
  30
  31 struct deferred_open_record {
  32         BOOL delayed_for_oplocks;
  33         SMB_DEV_T dev;
  34         SMB_INO_T inode;
  35 };
  36
  37 /****************************************************************************
  38  fd support routines - attempt to do a dos_open.
  39 ****************************************************************************/
  40
  41 static 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)
 612 {
 613         int i;
 614         struct share_mode_entry *exclusive = NULL;
 615         BOOL delay_it = False;
 616         BOOL have_level2 = False;
 617
 618         if (is_stat_open(fsp->access_mask)) {
 619                 fsp->oplock_type = NO_OPLOCK;
 620                 return False;
 621         }
 622
 623         if (lck->num_share_modes == 0) {
 624                 /* No files open at all: Directly grant whatever the client
 625                  * wants. */
 626
 627                 if (fsp->oplock_type == NO_OPLOCK) {
 628                         /* Store a level2 oplock, but don't tell the client */
 629                         fsp->oplock_type = FAKE_LEVEL_II_OPLOCK;
 630                 }
 631                 return False;
 632         }
 633
 634         for (i=0; i<lck->num_share_modes; i++) {
 635
 636                 if (!is_valid_share_mode_entry(&lck->share_modes[i])) {
 637                         continue;
 638                 }
 639
 640                 if (EXCLUSIVE_OPLOCK_TYPE(lck->share_modes[i].op_type)) {
 641                         SMB_ASSERT(exclusive == NULL);
 642                         exclusive = &lck->share_modes[i];
 643                 }
 644
 645                 if (lck->share_modes[i].op_type == LEVEL_II_OPLOCK) {
 646                         have_level2 = True;
 647                 }
 648         }
 649
 650         if (exclusive != NULL) { /* Found an exclusive oplock */
 651                 SMB_ASSERT(!have_level2);
 652                 delay_it = is_delete_request(fsp) ?
 653                         BATCH_OPLOCK_TYPE(exclusive->op_type) : True;
 654         }
 655
 656         if (EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type)) {
 657                 /* We can at most grant level2 */
 658                 fsp->oplock_type = LEVEL_II_OPLOCK;
 659         }
 660
 661         if ((fsp->oplock_type == NO_OPLOCK) && have_level2) {
 662                 /* Store a level2 oplock, but don't tell the client */
 663                 fsp->oplock_type = FAKE_LEVEL_II_OPLOCK;
 664         }
 665
 666         if (delay_it) {
 667                 BOOL ret;
 668                 char msg[MSG_SMB_SHARE_MODE_ENTRY_SIZE];
 669
 670                 DEBUG(10, ("Sending break request to PID %s\n",
 671                            procid_str_static(&exclusive->pid)));
 672                 exclusive->op_mid = get_current_mid();
 673
 674                 share_mode_entry_to_message(msg, exclusive);
 675
 676                 become_root();
 677                 ret = message_send_pid(exclusive->pid, MSG_SMB_BREAK_REQUEST,
 678                                        msg, MSG_SMB_SHARE_MODE_ENTRY_SIZE, True);
 679                 unbecome_root();
 680                 if (!ret) {
 681                         DEBUG(3, ("Could not send oplock break message\n"));
 682                 }
 683                 file_free(fsp);
 684         }
 685
 686         return delay_it;
 687 }
 688
 689 static BOOL request_timed_out(struct timeval request_time,
 690                               struct timeval timeout)
 691 {
 692         struct timeval now, end_time;
 693         GetTimeOfDay(&now);
 694         end_time = timeval_sum(&request_time, &timeout);
 695         return (timeval_compare(&end_time, &now) < 0);
 696 }
 697
 698 /****************************************************************************
 699  Handle the 1 second delay in returning a SHARING_VIOLATION error.
 700 ****************************************************************************/
 701
 702 static void defer_open(struct share_mode_lock *lck,
 703                        struct timeval request_time,
 704                        struct timeval timeout,
 705                        struct deferred_open_record *state)
 706 {
 707         uint16 mid = get_current_mid();
 708         int i;
 709
 710         /* Paranoia check */
 711
 712         for (i=0; i<lck->num_share_modes; i++) {
 713                 struct share_mode_entry *e = &lck->share_modes[i];
 714
 715                 if (!is_deferred_open_entry(e)) {
 716                         continue;
 717                 }
 718
 719                 if (procid_is_me(&e->pid) && (e->op_mid == mid)) {
 720                         DEBUG(0, ("Trying to defer an already deferred "
 721                                   "request: mid=%d, exiting\n", mid));
 722                         exit_server("exiting");
 723                 }
 724         }
 725
 726         /* End paranoia check */
 727
 728         DEBUG(10,("defer_open_sharing_error: time [%u.%06u] adding deferred "
 729                   "open entry for mid %u\n",
 730                   (unsigned int)request_time.tv_sec,
 731                   (unsigned int)request_time.tv_usec,
 732                   (unsigned int)mid));
 733
 734         if (!push_deferred_smb_message(mid, request_time, timeout,
 735                                        (char *)state, sizeof(*state))) {
 736                 exit_server("push_deferred_smb_message failed\n");
 737         }
 738         add_deferred_open(lck, mid, request_time, state->dev, state->inode);
 739
 740         /*
 741          * Push the MID of this packet on the signing queue.
 742          * We only do this once, the first time we push the packet
 743          * onto the deferred open queue, as this has a side effect
 744          * of incrementing the response sequence number.
 745          */
 746
 747         srv_defer_sign_response(mid);
 748 }
 749
 750 /****************************************************************************
 751  Set a kernel flock on a file for NFS interoperability.
 752  This requires a patch to Linux.
 753 ****************************************************************************/
 754
 755 static void kernel_flock(files_struct *fsp, uint32 share_mode)
 756 {
 757 #if HAVE_KERNEL_SHARE_MODES
 758         int kernel_mode = 0;
 759         if (share_mode == FILE_SHARE_WRITE) {
 760                 kernel_mode = LOCK_MAND|LOCK_WRITE;
 761         } else if (share_mode == FILE_SHARE_READ) {
 762                 kernel_mode = LOCK_MAND|LOCK_READ;
 763         } else if (share_mode == FILE_SHARE_NONE) {
 764                 kernel_mode = LOCK_MAND;
 765         }
 766         if (kernel_mode) {
 767                 flock(fsp->fh->fd, kernel_mode);
 768         }
 769 #endif
 770         ;
 771 }
 772
 773 /****************************************************************************
 774  On overwrite open ensure that the attributes match.
 775 ****************************************************************************/
 776
 777 static BOOL open_match_attributes(connection_struct *conn,
 778                                 const char *path,
 779                                 uint32 old_dos_attr,
 780                                 uint32 new_dos_attr,
 781                                 mode_t existing_unx_mode,
 782                                 mode_t new_unx_mode,
 783                                 mode_t *returned_unx_mode)
 784 {
 785         uint32 noarch_old_dos_attr, noarch_new_dos_attr;
 786
 787         noarch_old_dos_attr = (old_dos_attr & ~FILE_ATTRIBUTE_ARCHIVE);
 788         noarch_new_dos_attr = (new_dos_attr & ~FILE_ATTRIBUTE_ARCHIVE);
 789
 790         if((noarch_old_dos_attr == 0 && noarch_new_dos_attr != 0) ||
 791            (noarch_old_dos_attr != 0 && ((noarch_old_dos_attr & noarch_new_dos_attr) == noarch_old_dos_attr))) {
 792                 *returned_unx_mode = new_unx_mode;
 793         } else {
 794                 *returned_unx_mode = (mode_t)0;
 795         }
 796
 797         DEBUG(10,("open_match_attributes: file %s old_dos_attr = 0x%x, "
 798                   "existing_unx_mode = 0%o, new_dos_attr = 0x%x "
 799                   "returned_unx_mode = 0%o\n",
 800                   path,
 801                   (unsigned int)old_dos_attr,
 802                   (unsigned int)existing_unx_mode,
 803                   (unsigned int)new_dos_attr,
 804                   (unsigned int)*returned_unx_mode ));
 805
 806         /* If we're mapping SYSTEM and HIDDEN ensure they match. */
 807         if (lp_map_system(SNUM(conn)) || lp_store_dos_attributes(SNUM(conn))) {
 808                 if ((old_dos_attr & FILE_ATTRIBUTE_SYSTEM) &&
 809                     !(new_dos_attr & FILE_ATTRIBUTE_SYSTEM)) {
 810                         return False;
 811                 }
 812         }
 813         if (lp_map_hidden(SNUM(conn)) || lp_store_dos_attributes(SNUM(conn))) {
 814                 if ((old_dos_attr & FILE_ATTRIBUTE_HIDDEN) &&
 815                     !(new_dos_attr & FILE_ATTRIBUTE_HIDDEN)) {
 816                         return False;
 817                 }
 818         }
 819         return True;
 820 }
 821
 822 /****************************************************************************
 823  Special FCB or DOS processing in the case of a sharing violation.
 824  Try and find a duplicated file handle.
 825 ****************************************************************************/
 826
 827 static files_struct *fcb_or_dos_open(connection_struct *conn,
 828                                      const char *fname, SMB_DEV_T dev,
 829                                      SMB_INO_T inode,
 830                                      uint32 access_mask,
 831                                      uint32 share_access,
 832                                      uint32 create_options)
 833 {
 834         files_struct *fsp;
 835         files_struct *dup_fsp;
 836
 837         DEBUG(5,("fcb_or_dos_open: attempting old open semantics for "
 838                  "file %s.\n", fname ));
 839
 840         for(fsp = file_find_di_first(dev, inode); fsp;
 841             fsp = file_find_di_next(fsp)) {
 842
 843                 DEBUG(10,("fcb_or_dos_open: checking file %s, fd = %d, "
 844                           "vuid = %u, file_pid = %u, private_options = 0x%x "
 845                           "access_mask = 0x%x\n", fsp->fsp_name,
 846                           fsp->fh->fd, (unsigned int)fsp->vuid,
 847                           (unsigned int)fsp->file_pid,
 848                           (unsigned int)fsp->fh->private_options,
 849                           (unsigned int)fsp->access_mask ));
 850
 851                 if (fsp->fh->fd != -1 &&
 852                     fsp->vuid == current_user.vuid &&
 853                     fsp->file_pid == global_smbpid &&
 854                     (fsp->fh->private_options & (NTCREATEX_OPTIONS_PRIVATE_DENY_DOS |
 855                                                  NTCREATEX_OPTIONS_PRIVATE_DENY_FCB)) &&
 856                     (fsp->access_mask & FILE_WRITE_DATA) &&
 857                     strequal(fsp->fsp_name, fname)) {
 858                         DEBUG(10,("fcb_or_dos_open: file match\n"));
 859                         break;
 860                 }
 861         }
 862
 863         if (!fsp) {
 864                 return NULL;
 865         }
 866
 867         /* quite an insane set of semantics ... */
 868         if (is_executable(fname) &&
 869             (fsp->fh->private_options & NTCREATEX_OPTIONS_PRIVATE_DENY_DOS)) {
 870                 DEBUG(10,("fcb_or_dos_open: file fail due to is_executable.\n"));
 871                 return NULL;
 872         }
 873
 874         /* We need to duplicate this fsp. */
 875         dup_fsp = dup_file_fsp(fsp, access_mask, share_access, create_options);
 876         if (!dup_fsp) {
 877                 return NULL;
 878         }
 879
 880         return dup_fsp;
 881 }
 882
 883 /****************************************************************************
 884  Open a file with a share mode - old openX method - map into NTCreate.
 885 ****************************************************************************/
 886
 887 BOOL map_open_params_to_ntcreate(const char *fname, int deny_mode, int open_func,
 888                                 uint32 *paccess_mask,
 889                                 uint32 *pshare_mode,
 890                                 uint32 *pcreate_disposition,
 891                                 uint32 *pcreate_options)
 892 {
 893         uint32 access_mask;
 894         uint32 share_mode;
 895         uint32 create_disposition;
 896         uint32 create_options = 0;
 897
 898         DEBUG(10,("map_open_params_to_ntcreate: fname = %s, deny_mode = 0x%x, "
 899                   "open_func = 0x%x\n",
 900                   fname, (unsigned int)deny_mode, (unsigned int)open_func ));
 901
 902         /* Create the NT compatible access_mask. */
 903         switch (GET_OPENX_MODE(deny_mode)) {
 904                 case DOS_OPEN_EXEC: /* Implies read-only - used to be FILE_READ_DATA */
 905                 case DOS_OPEN_RDONLY:
 906                         access_mask = FILE_GENERIC_READ;
 907                         break;
 908                 case DOS_OPEN_WRONLY:
 909                         access_mask = FILE_GENERIC_WRITE;
 910                         break;
 911                 case DOS_OPEN_RDWR:
 912                 case DOS_OPEN_FCB:
 913                         access_mask = FILE_GENERIC_READ|FILE_GENERIC_WRITE;
 914                         break;
 915                 default:
 916                         DEBUG(10,("map_open_params_to_ntcreate: bad open mode = 0x%x\n",
 917                                   (unsigned int)GET_OPENX_MODE(deny_mode)));
 918                         return False;
 919         }
 920
 921         /* Create the NT compatible create_disposition. */
 922         switch (open_func) {
 923                 case OPENX_FILE_EXISTS_FAIL|OPENX_FILE_CREATE_IF_NOT_EXIST:
 924                         create_disposition = FILE_CREATE;
 925                         break;
 926
 927                 case OPENX_FILE_EXISTS_OPEN:
 928                         create_disposition = FILE_OPEN;
 929                         break;
 930
 931                 case OPENX_FILE_EXISTS_OPEN|OPENX_FILE_CREATE_IF_NOT_EXIST:
 932                         create_disposition = FILE_OPEN_IF;
 933                         break;
 934
 935                 case OPENX_FILE_EXISTS_TRUNCATE:
 936                         create_disposition = FILE_OVERWRITE;
 937                         break;
 938
 939                 case OPENX_FILE_EXISTS_TRUNCATE|OPENX_FILE_CREATE_IF_NOT_EXIST:
 940                         create_disposition = FILE_OVERWRITE_IF;
 941                         break;
 942
 943                 default:
 944                         /* From samba4 - to be confirmed. */
 945                         if (GET_OPENX_MODE(deny_mode) == DOS_OPEN_EXEC) {
 946                                 create_disposition = FILE_CREATE;
 947                                 break;
 948                         }
 949                         DEBUG(10,("map_open_params_to_ntcreate: bad "
 950                                   "open_func 0x%x\n", (unsigned int)open_func));
 951                         return False;
 952         }
 953
 954         /* Create the NT compatible share modes. */
 955         switch (GET_DENY_MODE(deny_mode)) {
 956                 case DENY_ALL:
 957                         share_mode = FILE_SHARE_NONE;
 958                         break;
 959
 960                 case DENY_WRITE:
 961                         share_mode = FILE_SHARE_READ;
 962                         break;
 963
 964                 case DENY_READ:
 965                         share_mode = FILE_SHARE_WRITE;
 966                         break;
 967
 968                 case DENY_NONE:
 969                         share_mode = FILE_SHARE_READ|FILE_SHARE_WRITE;
 970                         break;
 971
 972                 case DENY_DOS:
 973                         create_options |= NTCREATEX_OPTIONS_PRIVATE_DENY_DOS;
 974                         if (is_executable(fname)) {
 975                                 share_mode = FILE_SHARE_READ|FILE_SHARE_WRITE;
 976                         } else {
 977                                 if (GET_OPENX_MODE(deny_mode) == DOS_OPEN_RDONLY) {
 978                                         share_mode = FILE_SHARE_READ;
 979                                 } else {
 980                                         share_mode = FILE_SHARE_NONE;
 981                                 }
 982                         }
 983                         break;
 984
 985                 case DENY_FCB:
 986                         create_options |= NTCREATEX_OPTIONS_PRIVATE_DENY_FCB;
 987                         share_mode = FILE_SHARE_NONE;
 988                         break;
 989
 990                 default:
 991                         DEBUG(10,("map_open_params_to_ntcreate: bad deny_mode 0x%x\n",
 992                                 (unsigned int)GET_DENY_MODE(deny_mode) ));
 993                         return False;
 994         }
 995
 996         DEBUG(10,("map_open_params_to_ntcreate: file %s, access_mask = 0x%x, "
 997                   "share_mode = 0x%x, create_disposition = 0x%x, "
 998                   "create_options = 0x%x\n",
 999                   fname,
1000                   (unsigned int)access_mask,
1001                   (unsigned int)share_mode,
1002                   (unsigned int)create_disposition,
1003                   (unsigned int)create_options ));
1004
1005         if (paccess_mask) {
1006                 *paccess_mask = access_mask;
1007         }
1008         if (pshare_mode) {
1009                 *pshare_mode = share_mode;
1010         }
1011         if (pcreate_disposition) {
1012                 *pcreate_disposition = create_disposition;
1013         }
1014         if (pcreate_options) {
1015                 *pcreate_options = create_options;
1016         }
1017
1018         return True;
1019
1020 }
1021
1022 /****************************************************************************
1023  Open a file with a share mode.
1024 ****************************************************************************/
1025
1026 files_struct *open_file_ntcreate(connection_struct *conn,
1027                                  const char *fname,
1028                                  SMB_STRUCT_STAT *psbuf,
1029                                  uint32 access_mask,            /* access bits (FILE_READ_DATA etc.) */
1030                                  uint32 share_access,           /* share constants (FILE_SHARE_READ etc). */
1031                                  uint32 create_disposition,     /* FILE_OPEN_IF etc. */
1032                                  uint32 create_options,         /* options such as delete on close. */
1033                                  uint32 new_dos_attributes,     /* attributes used for new file. */
1034                                  int oplock_request,            /* internal Samba oplock codes. */
1035                                                                 /* Information (FILE_EXISTS etc.) */
1036                                  int *pinfo)
1037 {
1038         int flags=0;
1039         int flags2=0;
1040         BOOL file_existed = VALID_STAT(*psbuf);
1041         BOOL def_acl = False;
1042         BOOL internal_only_open = False;
1043         SMB_DEV_T dev = 0;
1044         SMB_INO_T inode = 0;
1045         BOOL fsp_open = False;
1046         files_struct *fsp = NULL;
1047         mode_t new_unx_mode = (mode_t)0;
1048         mode_t unx_mode = (mode_t)0;
1049         int info;
1050         uint32 existing_dos_attributes = 0;
1051         struct pending_message_list *pml = NULL;
1052         uint16 mid = get_current_mid();
1053         BOOL delayed_for_oplocks = False;
1054         struct timeval request_time = timeval_zero();
1055         struct share_mode_lock *lck = NULL;
1056         NTSTATUS status;
1057
1058         if (conn->printer) {
1059                 /*
1060                  * Printers are handled completely differently.
1061                  * Most of the passed parameters are ignored.
1062                  */
1063
1064                 if (pinfo) {
1065                         *pinfo = FILE_WAS_CREATED;
1066                 }
1067
1068                 DEBUG(10, ("open_file_ntcreate: printer open fname=%s\n", fname));
1069
1070                 return print_fsp_open(conn, fname);
1071         }
1072
1073         /* We add aARCH to this as this mode is only used if the file is
1074          * created new. */
1075         unx_mode = unix_mode(conn, new_dos_attributes | aARCH,fname, True);
1076
1077         DEBUG(10, ("open_file_ntcreate: fname=%s, dos_attrs=0x%x "
1078                    "access_mask=0x%x share_access=0x%x "
1079                    "create_disposition = 0x%x create_options=0x%x "
1080                    "unix mode=0%o oplock_request=%d\n",
1081                    fname, new_dos_attributes, access_mask, share_access,
1082                    create_disposition, create_options, unx_mode,
1083                    oplock_request));
1084
1085         if (oplock_request == INTERNAL_OPEN_ONLY) {
1086                 internal_only_open = True;
1087                 oplock_request = 0;
1088         }
1089
1090         if ((pml = get_open_deferred_message(mid)) != NULL) {
1091                 struct deferred_open_record *state =
1092                         (struct deferred_open_record *)pml->private_data.data;
1093
1094                 request_time = pml->request_time;
1095                 delayed_for_oplocks = state->delayed_for_oplocks;
1096
1097                 /* There could be a race condition where the dev/inode pair
1098                    has changed since we deferred the message. If so, just
1099                    remove the deferred open entry and return sharing
1100                    violation. */
1101
1102                 /* If the timeout value is non-zero, we need to just return
1103                    sharing violation. Don't retry the open as we were not
1104                    notified of a close and we don't want to trigger another
1105                    spurious oplock break. */
1106
1107                 /* Now remove the deferred open entry under lock. */
1108                 lck = get_share_mode_lock(NULL, state->dev, state->inode, NULL, NULL);
1109                 if (lck == NULL) {
1110                         DEBUG(0, ("could not get share mode lock\n"));
1111                 } else {
1112                         del_deferred_open_entry(lck, mid);
1113                         talloc_destroy(lck);
1114                 }
1115
1116                 /* Ensure we don't reprocess this message. */
1117                 remove_deferred_open_smb_message(mid);
1118         }
1119
1120         if (!check_name(fname,conn)) {
1121                 return NULL;
1122         }
1123
1124         new_dos_attributes &= SAMBA_ATTRIBUTES_MASK;
1125         if (file_existed) {
1126                 existing_dos_attributes = dos_mode(conn, fname, psbuf);
1127         }
1128
1129         /* ignore any oplock requests if oplocks are disabled */
1130         if (!lp_oplocks(SNUM(conn)) || global_client_failed_oplock_break ||
1131             IS_VETO_OPLOCK_PATH(conn, fname)) {
1132                 oplock_request = 0;
1133         }
1134
1135         /* this is for OS/2 long file names - say we don't support them */
1136         if (!lp_posix_pathnames() && strstr(fname,".+,;=[].")) {
1137                 /* OS/2 Workplace shell fix may be main code stream in a later
1138                  * release. */
1139                 set_saved_error_triple(ERRDOS, ERRcannotopen,
1140                                        NT_STATUS_OBJECT_NAME_NOT_FOUND);
1141                 DEBUG(5,("open_file_ntcreate: OS/2 long filenames are not "
1142                          "supported.\n"));
1143                 return NULL;
1144         }
1145
1146         switch( create_disposition ) {
1147                 /*
1148                  * Currently we're using FILE_SUPERSEDE as the same as
1149                  * FILE_OVERWRITE_IF but they really are
1150                  * different. FILE_SUPERSEDE deletes an existing file
1151                  * (requiring delete access) then recreates it.
1152                  */
1153                 case FILE_SUPERSEDE:
1154                         /* If file exists replace/overwrite. If file doesn't
1155                          * exist create. */
1156                         flags2 |= (O_CREAT | O_TRUNC);
1157                         break;
1158
1159                 case FILE_OVERWRITE_IF:
1160                         /* If file exists replace/overwrite. If file doesn't
1161                          * exist create. */
1162                         flags2 |= (O_CREAT | O_TRUNC);
1163                         break;
1164
1165                 case FILE_OPEN:
1166                         /* If file exists open. If file doesn't exist error. */
1167                         if (!file_existed) {
1168                                 DEBUG(5,("open_file_ntcreate: FILE_OPEN "
1169                                          "requested for file %s and file "
1170                                          "doesn't exist.\n", fname ));
1171                                 set_saved_ntstatus(NT_STATUS_OBJECT_NAME_NOT_FOUND);
1172                                 errno = ENOENT;
1173                                 return NULL;
1174                         }
1175                         break;
1176
1177                 case FILE_OVERWRITE:
1178                         /* If file exists overwrite. If file doesn't exist
1179                          * error. */
1180                         if (!file_existed) {
1181                                 DEBUG(5,("open_file_ntcreate: FILE_OVERWRITE "
1182                                          "requested for file %s and file "
1183                                          "doesn't exist.\n", fname ));
1184                                 set_saved_ntstatus(NT_STATUS_OBJECT_NAME_NOT_FOUND);
1185                                 errno = ENOENT;
1186                                 return NULL;
1187                         }
1188                         flags2 |= O_TRUNC;
1189                         break;
1190
1191                 case FILE_CREATE:
1192                         /* If file exists error. If file doesn't exist
1193                          * create. */
1194                         if (file_existed) {
1195                                 DEBUG(5,("open_file_ntcreate: FILE_CREATE "
1196                                          "requested for file %s and file "
1197                                          "already exists.\n", fname ));
1198                                 if (S_ISDIR(psbuf->st_mode)) {
1199                                         errno = EISDIR;
1200                                 } else {
1201                                         errno = EEXIST;
1202                                 }
1203                                 return NULL;
1204                         }
1205                         flags2 |= (O_CREAT|O_EXCL);
1206                         break;
1207
1208                 case FILE_OPEN_IF:
1209                         /* If file exists open. If file doesn't exist
1210                          * create. */
1211                         flags2 |= O_CREAT;
1212                         break;
1213
1214                 default:
1215                         set_saved_ntstatus(NT_STATUS_INVALID_PARAMETER);
1216                         return NULL;
1217         }
1218
1219         /* We only care about matching attributes on file exists and
1220          * overwrite. */
1221
1222         if (file_existed && ((create_disposition == FILE_OVERWRITE) ||
1223                              (create_disposition == FILE_OVERWRITE_IF))) {
1224                 if (!open_match_attributes(conn, fname,
1225                                            existing_dos_attributes,
1226                                            new_dos_attributes, psbuf->st_mode,
1227                                            unx_mode, &new_unx_mode)) {
1228                         DEBUG(5,("open_file_ntcreate: attributes missmatch "
1229                                  "for file %s (%x %x) (0%o, 0%o)\n",
1230                                  fname, existing_dos_attributes,
1231                                  new_dos_attributes,
1232                                  (unsigned int)psbuf->st_mode,
1233                                  (unsigned int)unx_mode ));
1234                         errno = EACCES;
1235                         return NULL;
1236                 }
1237         }
1238
1239         /* This is a nasty hack - must fix... JRA. */
1240         if (access_mask == MAXIMUM_ALLOWED_ACCESS) {
1241                 access_mask = FILE_GENERIC_ALL;
1242         }
1243
1244         /*
1245          * Convert GENERIC bits to specific bits.
1246          */
1247
1248         se_map_generic(&access_mask, &file_generic_mapping);
1249
1250         DEBUG(10, ("open_file_ntcreate: fname=%s, after mapping "
1251                    "access_mask=0x%x\n", fname, access_mask ));
1252
1253         /*
1254          * Note that we ignore the append flag as append does not
1255          * mean the same thing under DOS and Unix.
1256          */
1257
1258         if (access_mask & (FILE_WRITE_DATA | FILE_APPEND_DATA)) {
1259                 flags = O_RDWR;
1260         } else {
1261                 flags = O_RDONLY;
1262         }
1263
1264         /*
1265          * Currently we only look at FILE_WRITE_THROUGH for create options.
1266          */
1267
1268 #if defined(O_SYNC)
1269         if (create_options & FILE_WRITE_THROUGH) {
1270                 flags2 |= O_SYNC;
1271         }
1272 #endif /* O_SYNC */
1273
1274         if (!CAN_WRITE(conn)) {
1275                 /*
1276                  * We should really return a permission denied error if either
1277                  * O_CREAT or O_TRUNC are set, but for compatibility with
1278                  * older versions of Samba we just AND them out.
1279                  */
1280                 flags2 &= ~(O_CREAT|O_TRUNC);
1281         }
1282
1283         /*
1284          * Ensure we can't write on a read-only share or file.
1285          */
1286
1287         if (flags != O_RDONLY && file_existed &&
1288             (!CAN_WRITE(conn) || IS_DOS_READONLY(existing_dos_attributes))) {
1289                 DEBUG(5,("open_file_ntcreate: write access requested for "
1290                          "file %s on read only %s\n",
1291                          fname, !CAN_WRITE(conn) ? "share" : "file" ));
1292                 set_saved_ntstatus(NT_STATUS_ACCESS_DENIED);
1293                 errno = EACCES;
1294                 return NULL;
1295         }
1296
1297         fsp = file_new(conn);
1298         if(!fsp) {
1299                 return NULL;
1300         }
1301
1302         fsp->dev = psbuf->st_dev;
1303         fsp->inode = psbuf->st_ino;
1304         fsp->share_access = share_access;
1305         fsp->fh->private_options = create_options;
1306         fsp->access_mask = access_mask;
1307         fsp->oplock_type = oplock_request;
1308
1309         if (timeval_is_zero(&request_time)) {
1310                 request_time = fsp->open_time;
1311         }
1312
1313         if (file_existed) {
1314
1315                 dev = psbuf->st_dev;
1316                 inode = psbuf->st_ino;
1317
1318                 lck = get_share_mode_lock(NULL, dev, inode,
1319                                         conn->connectpath,
1320                                         fname);
1321
1322                 if (lck == NULL) {
1323                         DEBUG(0, ("Could not get share mode lock\n"));
1324                         set_saved_ntstatus(NT_STATUS_SHARING_VIOLATION);
1325                         return NULL;
1326                 }
1327
1328                 if (delay_for_oplocks(lck, fsp)) {
1329                         struct deferred_open_record state;
1330                         struct timeval timeout;
1331
1332                         if (delayed_for_oplocks) {
1333                                 DEBUG(0, ("Trying to delay for oplocks "
1334                                           "twice\n"));
1335                                 exit_server("exiting");
1336                         }
1337
1338                         timeout = timeval_set(OPLOCK_BREAK_TIMEOUT*2, 0);
1339
1340                         /* Normally the smbd we asked should respond within
1341                          * OPLOCK_BREAK_TIMEOUT seconds regardless of whether
1342                          * the client did, give twice the timeout as a safety
1343                          * measure here in case the other smbd is stuck
1344                          * somewhere else. */
1345
1346                         state.delayed_for_oplocks = True;
1347                         state.dev = dev;
1348                         state.inode = inode;
1349
1350                         if (!request_timed_out(request_time, timeout)) {
1351                                 defer_open(lck, request_time, timeout,
1352                                            &state);
1353                         }
1354
1355                         talloc_free(lck);
1356                         return NULL;
1357                 }
1358
1359                 status = open_mode_check(conn, fname, lck,
1360                                          access_mask, share_access,
1361                                          create_options, &file_existed);
1362
1363                 if (NT_STATUS_EQUAL(status, NT_STATUS_DELETE_PENDING)) {
1364                         /* DELETE_PENDING is not deferred for a second */
1365                         set_saved_ntstatus(status);
1366                         talloc_free(lck);
1367                         file_free(fsp);
1368                         return NULL;
1369                 }
1370
1371                 if (!NT_STATUS_IS_OK(status)) {
1372
1373                         SMB_ASSERT(NT_STATUS_EQUAL(status, NT_STATUS_SHARING_VIOLATION));
1374
1375                         /* Check if this can be done with the deny_dos and fcb
1376                          * calls. */
1377                         if (create_options &
1378                             (NTCREATEX_OPTIONS_PRIVATE_DENY_DOS|
1379                              NTCREATEX_OPTIONS_PRIVATE_DENY_FCB)) {
1380                                 files_struct *fsp_dup;
1381                                 fsp_dup = fcb_or_dos_open(conn, fname, dev,
1382                                                           inode, access_mask,
1383                                                           share_access,
1384                                                           create_options);
1385
1386                                 if (fsp_dup) {
1387                                         talloc_free(lck);
1388                                         file_free(fsp);
1389                                         if (pinfo) {
1390                                                 *pinfo = FILE_WAS_OPENED;
1391                                         }
1392                                         conn->num_files_open++;
1393                                         return fsp_dup;
1394                                 }
1395                         }
1396
1397                         /*
1398                          * This next line is a subtlety we need for
1399                          * MS-Access. If a file open will fail due to share
1400                          * permissions and also for security (access) reasons,
1401                          * we need to return the access failed error, not the
1402                          * share error. This means we must attempt to open the
1403                          * file anyway in order to get the UNIX access error -
1404                          * even if we're going to fail the open for share
1405                          * reasons. This is bad, as we're burning another fd
1406                          * if there are existing locks but there's nothing
1407                          * else we can do. We also ensure we're not going to
1408                          * create or tuncate the file as we only want an
1409                          * access decision at this stage. JRA.
1410                          */
1411                         errno = 0;
1412                         fsp_open = open_file(fsp,conn,fname,psbuf,
1413                                              flags|(flags2&~(O_TRUNC|O_CREAT)),
1414                                              unx_mode,access_mask);
1415
1416                         DEBUG(4,("open_file_ntcreate : share_mode deny - "
1417                                  "calling open_file with flags=0x%X "
1418                                  "flags2=0x%X mode=0%o returned %d\n",
1419                                  flags, (flags2&~(O_TRUNC|O_CREAT)),
1420                                  (unsigned int)unx_mode, (int)fsp_open ));
1421
1422                         if (!fsp_open && errno) {
1423                                 /* Default error. */
1424                                 set_saved_ntstatus(NT_STATUS_ACCESS_DENIED);
1425                         }
1426
1427                         /*
1428                          * If we're returning a share violation, ensure we
1429                          * cope with the braindead 1 second delay.
1430                          */
1431
1432                         if (!internal_only_open &&
1433                             lp_defer_sharing_violations()) {
1434                                 struct timeval timeout;
1435                                 struct deferred_open_record state;
1436
1437                                 timeout = timeval_set(0, SHARING_VIOLATION_USEC_WAIT);
1438
1439                                 state.delayed_for_oplocks = False;
1440                                 state.dev = dev;
1441                                 state.inode = inode;
1442
1443                                 if (!request_timed_out(request_time,
1444                                                        timeout)) {
1445                                         defer_open(lck, request_time, timeout,
1446                                                    &state);
1447                                 }
1448                         }
1449
1450                         talloc_free(lck);
1451                         if (fsp_open) {
1452                                 fd_close(conn, fsp);
1453                                 /*
1454                                  * We have detected a sharing violation here
1455                                  * so return the correct error code
1456                                  */
1457                                 set_saved_ntstatus(NT_STATUS_SHARING_VIOLATION);
1458                         }
1459                         file_free(fsp);
1460                         return NULL;
1461                 }
1462
1463                 /*
1464                  * We exit this block with the share entry *locked*.....
1465                  */
1466         }
1467
1468         SMB_ASSERT(!file_existed || (lck != NULL));
1469
1470         /*
1471          * Ensure we pay attention to default ACLs on directories if required.
1472          */
1473
1474         if ((flags2 & O_CREAT) && lp_inherit_acls(SNUM(conn)) &&
1475             (def_acl = directory_has_default_acl(conn,
1476                                                  parent_dirname(fname)))) {
1477                 unx_mode = 0777;
1478         }
1479
1480         DEBUG(4,("calling open_file with flags=0x%X flags2=0x%X mode=0%o\n",
1481                  (unsigned int)flags, (unsigned int)flags2,
1482                  (unsigned int)unx_mode));
1483
1484         /*
1485          * open_file strips any O_TRUNC flags itself.
1486          */
1487
1488         fsp_open = open_file(fsp,conn,fname,psbuf,flags|flags2,unx_mode,
1489                              access_mask);
1490
1491         if (!fsp_open) {
1492                 if (lck != NULL) {
1493                         talloc_free(lck);
1494                 }
1495                 file_free(fsp);
1496                 return NULL;
1497         }
1498
1499         if (!file_existed) {
1500
1501                 /*
1502                  * Deal with the race condition where two smbd's detect the
1503                  * file doesn't exist and do the create at the same time. One
1504                  * of them will win and set a share mode, the other (ie. this
1505                  * one) should check if the requested share mode for this
1506                  * create is allowed.
1507                  */
1508
1509                 /*
1510                  * Now the file exists and fsp is successfully opened,
1511                  * fsp->dev and fsp->inode are valid and should replace the
1512                  * dev=0,inode=0 from a non existent file. Spotted by
1513                  * Nadav Danieli <nadavd@exanet.com>. JRA.
1514                  */
1515
1516                 dev = fsp->dev;
1517                 inode = fsp->inode;
1518
1519                 lck = get_share_mode_lock(NULL, dev, inode,
1520                                         conn->connectpath,
1521                                         fname);
1522
1523                 if (lck == NULL) {
1524                         DEBUG(0, ("open_file_ntcreate: Could not get share mode lock for %s\n", fname));
1525                         fd_close(conn, fsp);
1526                         file_free(fsp);
1527                         set_saved_ntstatus(NT_STATUS_SHARING_VIOLATION);
1528                         return NULL;
1529                 }
1530
1531                 status = open_mode_check(conn, fname, lck,
1532                                          access_mask, share_access,
1533                                          create_options, &file_existed);
1534
1535                 if (!NT_STATUS_IS_OK(status)) {
1536                         struct deferred_open_record state;
1537
1538                         fd_close(conn, fsp);
1539                         file_free(fsp);
1540
1541                         state.delayed_for_oplocks = False;
1542                         state.dev = dev;
1543                         state.inode = inode;
1544
1545                         /* Do it all over again immediately. In the second
1546                          * round we will find that the file existed and handle
1547                          * the DELETE_PENDING and FCB cases correctly. No need
1548                          * to duplicate the code here. Essentially this is a
1549                          * "goto top of this function", but don't tell
1550                          * anybody... */
1551
1552                         defer_open(lck, request_time, timeval_zero(),
1553                                    &state);
1554                         talloc_free(lck);
1555                         return NULL;
1556                 }
1557
1558                 /*
1559                  * We exit this block with the share entry *locked*.....
1560                  */
1561         }
1562
1563         SMB_ASSERT(lck != NULL);
1564
1565         /* note that we ignore failure for the following. It is
1566            basically a hack for NFS, and NFS will never set one of
1567            these only read them. Nobody but Samba can ever set a deny
1568            mode and we have already checked our more authoritative
1569            locking database for permission to set this deny mode. If
1570            the kernel refuses the operations then the kernel is wrong */
1571
1572         kernel_flock(fsp, share_access);
1573
1574         /*
1575          * At this point onwards, we can guarentee that the share entry
1576          * is locked, whether we created the file or not, and that the
1577          * deny mode is compatible with all current opens.
1578          */
1579
1580         /*
1581          * If requested, truncate the file.
1582          */
1583
1584         if (flags2&O_TRUNC) {
1585                 /*
1586                  * We are modifing the file after open - update the stat
1587                  * struct..
1588                  */
1589                 if ((SMB_VFS_FTRUNCATE(fsp,fsp->fh->fd,0) == -1) ||
1590                     (SMB_VFS_FSTAT(fsp,fsp->fh->fd,psbuf)==-1)) {
1591                         talloc_free(lck);
1592                         fd_close(conn,fsp);
1593                         file_free(fsp);
1594                         return NULL;
1595                 }
1596         }
1597
1598         /* Record the options we were opened with. */
1599         fsp->share_access = share_access;
1600         fsp->fh->private_options = create_options;
1601         fsp->access_mask = access_mask;
1602
1603         if (file_existed) {
1604                 if (!(flags2 & O_TRUNC)) {
1605                         info = FILE_WAS_OPENED;
1606                 } else {
1607                         info = FILE_WAS_OVERWRITTEN;
1608                 }
1609         } else {
1610                 info = FILE_WAS_CREATED;
1611                 /* Change the owner if required. */
1612                 if (lp_inherit_owner(SNUM(conn))) {
1613                         change_owner_to_parent(conn, fsp, fsp->fsp_name,
1614                                                psbuf);
1615                 }
1616         }
1617
1618         if (pinfo) {
1619                 *pinfo = info;
1620         }
1621
1622         /*
1623          * Setup the oplock info in both the shared memory and
1624          * file structs.
1625          */
1626
1627         if ((fsp->oplock_type != NO_OPLOCK) &&
1628             (fsp->oplock_type != FAKE_LEVEL_II_OPLOCK)) {
1629                 if (!set_file_oplock(fsp, fsp->oplock_type)) {
1630                         /* Could not get the kernel oplock */
1631                         fsp->oplock_type = NO_OPLOCK;
1632                 }
1633         }
1634         set_share_mode(lck, fsp, 0, fsp->oplock_type);
1635
1636         if (info == FILE_WAS_OVERWRITTEN || info == FILE_WAS_CREATED ||
1637                                 info == FILE_WAS_SUPERSEDED) {
1638
1639                 /* Handle strange delete on close create semantics. */
1640                 if (create_options & FILE_DELETE_ON_CLOSE) {
1641                         NTSTATUS result = can_set_delete_on_close(fsp, True, new_dos_attributes);
1642
1643                         if (!NT_STATUS_IS_OK(result)) {
1644                                 /* Remember to delete the mode we just added. */
1645                                 del_share_mode(lck, fsp);
1646                                 talloc_free(lck);
1647                                 fd_close(conn,fsp);
1648                                 file_free(fsp);
1649                                 set_saved_ntstatus(result);
1650                                 return NULL;
1651                         }
1652                         /* Note that here we set the *inital* delete on close flag,
1653                            not the regular one. */
1654                         set_delete_on_close_token(lck, &current_user.ut);
1655                         lck->initial_delete_on_close = True;
1656                         lck->modified = True;
1657                 }
1658
1659                 /* Files should be initially set as archive */
1660                 if (lp_map_archive(SNUM(conn)) ||
1661                     lp_store_dos_attributes(SNUM(conn))) {
1662                         file_set_dosmode(conn, fname,
1663                                          new_dos_attributes | aARCH, NULL,
1664                                          True);
1665                 }
1666         }
1667
1668         /*
1669          * Take care of inherited ACLs on created files - if default ACL not
1670          * selected.
1671          */
1672
1673         if (!file_existed && !def_acl) {
1674
1675                 int saved_errno = errno; /* We might get ENOSYS in the next
1676                                           * call.. */
1677
1678                 if (SMB_VFS_FCHMOD_ACL(fsp, fsp->fh->fd, unx_mode) == -1
1679                     && errno == ENOSYS) {
1680                         errno = saved_errno; /* Ignore ENOSYS */
1681                 }
1682
1683         } else if (new_unx_mode) {
1684
1685                 int ret = -1;
1686
1687                 /* Attributes need changing. File already existed. */
1688
1689                 {
1690                         int saved_errno = errno; /* We might get ENOSYS in the
1691                                                   * next call.. */
1692                         ret = SMB_VFS_FCHMOD_ACL(fsp, fsp->fh->fd,
1693                                                  new_unx_mode);
1694
1695                         if (ret == -1 && errno == ENOSYS) {
1696                                 errno = saved_errno; /* Ignore ENOSYS */
1697                         } else {
1698                                 DEBUG(5, ("open_file_shared: reset "
1699                                           "attributes of file %s to 0%o\n",
1700                                         fname, (unsigned int)new_unx_mode));
1701                                 ret = 0; /* Don't do the fchmod below. */
1702                         }
1703                 }
1704
1705                 if ((ret == -1) &&
1706                     (SMB_VFS_FCHMOD(fsp, fsp->fh->fd, new_unx_mode) == -1))
1707                         DEBUG(5, ("open_file_shared: failed to reset "
1708                                   "attributes of file %s to 0%o\n",
1709                                 fname, (unsigned int)new_unx_mode));
1710         }
1711
1712         /* If this is a successful open, we must remove any deferred open
1713          * records. */
1714         del_deferred_open_entry(lck, mid);
1715         talloc_free(lck);
1716
1717         conn->num_files_open++;
1718
1719         return fsp;
1720 }
1721
1722 /****************************************************************************
1723  Open a file for for write to ensure that we can fchmod it.
1724 ****************************************************************************/
1725
1726 files_struct *open_file_fchmod(connection_struct *conn, const char *fname,
1727                                SMB_STRUCT_STAT *psbuf)
1728 {
1729         files_struct *fsp = NULL;
1730         BOOL fsp_open;
1731
1732         if (!VALID_STAT(*psbuf)) {
1733                 return NULL;
1734         }
1735
1736         fsp = file_new(conn);
1737         if(!fsp) {
1738                 return NULL;
1739         }
1740
1741         /* note! we must use a non-zero desired access or we don't get
1742            a real file descriptor. Oh what a twisted web we weave. */
1743         fsp_open = open_file(fsp,conn,fname,psbuf,O_WRONLY,0,FILE_WRITE_DATA);
1744
1745         /*
1746          * This is not a user visible file open.
1747          * Don't set a share mode and don't increment
1748          * the conn->num_files_open.
1749          */
1750
1751         if (!fsp_open) {
1752                 file_free(fsp);
1753                 return NULL;
1754         }
1755
1756         return fsp;
1757 }
1758
1759 /****************************************************************************
1760  Close the fchmod file fd - ensure no locks are lost.
1761 ****************************************************************************/
1762
1763 int close_file_fchmod(files_struct *fsp)
1764 {
1765         int ret = fd_close(fsp->conn, fsp);
1766         file_free(fsp);
1767         return ret;
1768 }
1769
1770 /****************************************************************************
1771  Open a directory from an NT SMB call.
1772 ****************************************************************************/
1773
1774 files_struct *open_directory(connection_struct *conn,
1775                                 const char *fname,
1776                                 SMB_STRUCT_STAT *psbuf,
1777                                 uint32 access_mask,
1778                                 uint32 share_access,
1779                                 uint32 create_disposition,
1780                                 uint32 create_options,
1781                                 int *pinfo)
1782 {
1783         files_struct *fsp = NULL;
1784         BOOL dir_existed = VALID_STAT(*psbuf) ? True : False;
1785         BOOL create_dir = False;
1786         struct share_mode_lock *lck = NULL;
1787         NTSTATUS status;
1788         int info = 0;
1789
1790         DEBUG(5,("open_directory: opening directory %s, access_mask = 0x%x, "
1791                  "share_access = 0x%x create_options = 0x%x, "
1792                  "create_disposition = 0x%x\n",
1793                  fname,
1794                  (unsigned int)access_mask,
1795                  (unsigned int)share_access,
1796                  (unsigned int)create_options,
1797                  (unsigned int)create_disposition));
1798
1799         if (is_ntfs_stream_name(fname)) {
1800                 DEBUG(0,("open_directory: %s is a stream name!\n", fname ));
1801                 set_saved_ntstatus(NT_STATUS_NOT_A_DIRECTORY);
1802                 return NULL;
1803         }
1804
1805         if (dir_existed && !S_ISDIR(psbuf->st_mode)) {
1806                 DEBUG(0,("open_directory: %s is not a directory !\n", fname ));
1807                 set_saved_ntstatus(NT_STATUS_NOT_A_DIRECTORY);
1808                 return NULL;
1809         }
1810
1811         switch( create_disposition ) {
1812                 case FILE_OPEN:
1813                         /* If directory exists open. If directory doesn't
1814                          * exist error. */
1815                         if (!dir_existed) {
1816                                 DEBUG(5,("open_directory: FILE_OPEN requested "
1817                                          "for directory %s and it doesn't "
1818                                          "exist.\n", fname ));
1819                                 set_saved_ntstatus(NT_STATUS_OBJECT_NAME_NOT_FOUND);
1820                                 return NULL;
1821                         }
1822                         info = FILE_WAS_OPENED;
1823                         break;
1824
1825                 case FILE_CREATE:
1826                         /* If directory exists error. If directory doesn't
1827                          * exist create. */
1828                         if (dir_existed) {
1829                                 DEBUG(5,("open_directory: FILE_CREATE "
1830                                          "requested for directory %s and it "
1831                                          "already exists.\n", fname ));
1832                                 set_saved_error_triple(ERRDOS, ERRfilexists,
1833                                                        NT_STATUS_OBJECT_NAME_COLLISION);
1834                                 return NULL;
1835                         }
1836                         create_dir = True;
1837                         info = FILE_WAS_CREATED;
1838                         break;
1839
1840                 case FILE_OPEN_IF:
1841                         /* If directory exists open. If directory doesn't
1842                          * exist create. */
1843                         if (!dir_existed) {
1844                                 create_dir = True;
1845                                 info = FILE_WAS_CREATED;
1846                         } else {
1847                                 info = FILE_WAS_OPENED;
1848                         }
1849                         break;
1850
1851                 case FILE_SUPERSEDE:
1852                 case FILE_OVERWRITE:
1853                 case FILE_OVERWRITE_IF:
1854                 default:
1855                         DEBUG(5,("open_directory: invalid create_disposition "
1856                                  "0x%x for directory %s\n",
1857                                  (unsigned int)create_disposition, fname));
1858                         file_free(fsp);
1859                         set_saved_ntstatus(NT_STATUS_INVALID_PARAMETER);
1860                         return NULL;
1861         }
1862
1863         if (create_dir) {
1864                 /*
1865                  * Try and create the directory.
1866                  */
1867
1868                 /* We know bad_path is false as it's caught earlier. */
1869
1870                 status = mkdir_internal(conn, fname, False);
1871
1872                 if (!NT_STATUS_IS_OK(status)) {
1873                         DEBUG(2,("open_directory: unable to create %s. "
1874                                  "Error was %s\n", fname, strerror(errno) ));
1875                         /* Ensure we return the correct NT status to the
1876                          * client. */
1877                         set_saved_error_triple(0, 0, status);
1878                         return NULL;
1879                 }
1880
1881                 /* Ensure we're checking for a symlink here.... */
1882                 /* We don't want to get caught by a symlink racer. */
1883
1884                 if(SMB_VFS_LSTAT(conn,fname, psbuf) != 0) {
1885                         return NULL;
1886                 }
1887
1888                 if(!S_ISDIR(psbuf->st_mode)) {
1889                         DEBUG(0,("open_directory: %s is not a directory !\n",
1890                                  fname ));
1891                         return NULL;
1892                 }
1893         }
1894
1895         fsp = file_new(conn);
1896         if(!fsp) {
1897                 return NULL;
1898         }
1899
1900         /*
1901          * Setup the files_struct for it.
1902          */
1903
1904         fsp->mode = psbuf->st_mode;
1905         fsp->inode = psbuf->st_ino;
1906         fsp->dev = psbuf->st_dev;
1907         fsp->vuid = current_user.vuid;
1908         fsp->file_pid = global_smbpid;
1909         fsp->can_lock = True;
1910         fsp->can_read = False;
1911         fsp->can_write = False;
1912
1913         fsp->share_access = share_access;
1914         fsp->fh->private_options = create_options;
1915         fsp->access_mask = access_mask;
1916
1917         fsp->print_file = False;
1918         fsp->modified = False;
1919         fsp->oplock_type = NO_OPLOCK;
1920         fsp->sent_oplock_break = NO_BREAK_SENT;
1921         fsp->is_directory = True;
1922         fsp->is_stat = False;
1923         string_set(&fsp->fsp_name,fname);
1924
1925         lck = get_share_mode_lock(NULL, fsp->dev, fsp->inode,
1926                                 conn->connectpath,
1927                                 fname);
1928
1929         if (lck == NULL) {
1930                 DEBUG(0, ("open_directory: Could not get share mode lock for %s\n", fname));
1931                 file_free(fsp);
1932                 set_saved_ntstatus(NT_STATUS_SHARING_VIOLATION);
1933                 return NULL;
1934         }
1935
1936         status = open_mode_check(conn, fname, lck,
1937                                 access_mask, share_access,
1938                                 create_options, &dir_existed);
1939
1940         if (!NT_STATUS_IS_OK(status)) {
1941                 set_saved_ntstatus(status);
1942                 talloc_free(lck);
1943                 file_free(fsp);
1944                 return NULL;
1945         }
1946
1947         set_share_mode(lck, fsp, 0, NO_OPLOCK);
1948
1949         /* For directories the delete on close bit at open time seems
1950            always to be honored on close... See test 19 in Samba4 BASE-DELETE. */
1951         if (create_options & FILE_DELETE_ON_CLOSE) {
1952                 status = can_set_delete_on_close(fsp, True, 0);
1953                 if (!NT_STATUS_IS_OK(status)) {
1954                         set_saved_ntstatus(status);
1955                         talloc_free(lck);
1956                         file_free(fsp);
1957                         return NULL;
1958                 }
1959
1960                 set_delete_on_close_token(lck, &current_user.ut);
1961                 lck->initial_delete_on_close = True;
1962                 lck->modified = True;
1963         }
1964
1965         talloc_free(lck);
1966
1967         /* Change the owner if required. */
1968         if ((info == FILE_WAS_CREATED) && lp_inherit_owner(SNUM(conn))) {
1969                 change_owner_to_parent(conn, fsp, fsp->fsp_name, psbuf);
1970         }
1971
1972         if (pinfo) {
1973                 *pinfo = info;
1974         }
1975
1976         conn->num_files_open++;
1977
1978         return fsp;
1979 }
1980
1981 /****************************************************************************
1982  Open a pseudo-file (no locking checks - a 'stat' open).
1983 ****************************************************************************/
1984
1985 files_struct *open_file_stat(connection_struct *conn, char *fname,
1986                              SMB_STRUCT_STAT *psbuf)
1987 {
1988         files_struct *fsp = NULL;
1989
1990         if (!VALID_STAT(*psbuf))
1991                 return NULL;
1992
1993         /* Can't 'stat' open directories. */
1994         if(S_ISDIR(psbuf->st_mode))
1995                 return NULL;
1996
1997         fsp = file_new(conn);
1998         if(!fsp)
1999                 return NULL;
2000
2001         DEBUG(5,("open_file_stat: 'opening' file %s\n", fname));
2002
2003         /*
2004          * Setup the files_struct for it.
2005          */
2006
2007         fsp->mode = psbuf->st_mode;
2008         fsp->inode = psbuf->st_ino;
2009         fsp->dev = psbuf->st_dev;
2010         fsp->vuid = current_user.vuid;
2011         fsp->file_pid = global_smbpid;
2012         fsp->can_lock = False;
2013         fsp->can_read = False;
2014         fsp->can_write = False;
2015         fsp->print_file = False;
2016         fsp->modified = False;
2017         fsp->oplock_type = NO_OPLOCK;
2018         fsp->sent_oplock_break = NO_BREAK_SENT;
2019         fsp->is_directory = False;
2020         fsp->is_stat = True;
2021         string_set(&fsp->fsp_name,fname);
2022
2023         conn->num_files_open++;
2024
2025         return fsp;
2026 }
2027
2028 /****************************************************************************
2029  Receive notification that one of our open files has been renamed by another
2030  smbd process.
2031 ****************************************************************************/
2032
2033 void msg_file_was_renamed(int msg_type, struct process_id src, void *buf, size_t len)
2034 {
2035         files_struct *fsp;
2036         char *frm = (char *)buf;
2037         SMB_DEV_T dev;
2038         SMB_INO_T inode;
2039         const char *sharepath;
2040         const char *newname;
2041         size_t sp_len;
2042
2043         if (buf == NULL || len < MSG_FILE_RENAMED_MIN_SIZE + 2) {
2044                 DEBUG(0, ("msg_file_was_renamed: Got invalid msg len %d\n", (int)len));
2045                 return;
2046         }
2047
2048         /* Unpack the message. */
2049         dev = DEV_T_VAL(frm,0);
2050         inode = INO_T_VAL(frm,8);
2051         sharepath = &frm[16];
2052         newname = sharepath + strlen(sharepath) + 1;
2053         sp_len = strlen(sharepath);
2054
2055         DEBUG(10,("msg_file_was_renamed: Got rename message for sharepath %s, new name %s, "
2056                 "dev %x, inode  %.0f\n",
2057                 sharepath, newname, (unsigned int)dev, (double)inode ));
2058
2059         for(fsp = file_find_di_first(dev, inode); fsp; fsp = file_find_di_next(fsp)) {
2060                 if (memcmp(fsp->conn->connectpath, sharepath, sp_len) == 0) {
2061                         DEBUG(10,("msg_file_was_renamed: renaming file fnum %d from %s -> %s\n",
2062                                 fsp->fnum, fsp->fsp_name, newname ));
2063                         string_set(&fsp->fsp_name, newname);
2064                 } else {
2065                         /* TODO. JRA. */
2066                         /* Now we have the complete path we can work out if this is
2067                            actually within this share and adjust newname accordingly. */
2068                         DEBUG(10,("msg_file_was_renamed: share mismatch (sharepath %s "
2069                                 "not sharepath %s) "
2070                                 "fnum %d from %s -> %s\n",
2071                                 fsp->conn->connectpath,
2072                                 sharepath,
2073                                 fsp->fnum,
2074                                 fsp->fsp_name,
2075                                 newname ));
2076                 }
2077         }
2078 }