source/smbd/open.c

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