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