source/smbd/open.c

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