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