source3/smbd/open.c

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