source3/smbd/open.c

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