source3/smbd/open.c

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