source/smbd/open.c

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