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 3 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, see <http://www.gnu.org/licenses/>.
  20 */
  21
  22 #include "includes.h"
  23 #include "system/filesys.h"
  24 #include "printing.h"
  25 #include "smbd/smbd.h"
  26 #include "smbd/globals.h"
  27 #include "fake_file.h"
  28 #include "../libcli/security/security.h"
  29 #include "../librpc/gen_ndr/ndr_security.h"
  30 #include "../librpc/gen_ndr/open_files.h"
  31 #include "../librpc/gen_ndr/idmap.h"
  32 #include "passdb/lookup_sid.h"
  33 #include "auth.h"
  34 #include "serverid.h"
  35 #include "messages.h"
  36 #include "source3/lib/dbwrap/dbwrap_watch.h"
  37
  38 extern const struct generic_mapping file_generic_mapping;
  39
  40 struct deferred_open_record {
  41         bool delayed_for_oplocks;
  42         bool async_open;
  43         struct file_id id;
  44 };
  45
  46 /****************************************************************************
  47  If the requester wanted DELETE_ACCESS and was rejected because
  48  the file ACL didn't include DELETE_ACCESS, see if the parent ACL
  49  overrides this.
  50 ****************************************************************************/
  51
  52 static bool parent_override_delete(connection_struct *conn,
  53                                         const struct smb_filename *smb_fname,
  54                                         uint32_t access_mask,
  55                                         uint32_t rejected_mask)
  56 {
  57         if ((access_mask & DELETE_ACCESS) &&
  58                     (rejected_mask & DELETE_ACCESS) &&
  59                     can_delete_file_in_directory(conn, smb_fname)) {
  60                 return true;
  61         }
  62         return false;
  63 }
  64
  65 /****************************************************************************
  66  Check if we have open rights.
  67 ****************************************************************************/
  68
  69 NTSTATUS smbd_check_access_rights(struct connection_struct *conn,
  70                                 const struct smb_filename *smb_fname,
  71                                 bool use_privs,
  72                                 uint32_t access_mask)
  73 {
  74         /* Check if we have rights to open. */
  75         NTSTATUS status;
  76         struct security_descriptor *sd = NULL;
  77         uint32_t rejected_share_access;
  78         uint32_t rejected_mask = access_mask;
  79
  80         rejected_share_access = access_mask & ~(conn->share_access);
  81
  82         if (rejected_share_access) {
  83                 DEBUG(10, ("smbd_check_access_rights: rejected share access 0x%x "
  84                         "on %s (0x%x)\n",
  85                         (unsigned int)access_mask,
  86                         smb_fname_str_dbg(smb_fname),
  87                         (unsigned int)rejected_share_access ));
  88                 return NT_STATUS_ACCESS_DENIED;
  89         }
  90
  91         if (!use_privs && get_current_uid(conn) == (uid_t)0) {
  92                 /* I'm sorry sir, I didn't know you were root... */
  93                 DEBUG(10,("smbd_check_access_rights: root override "
  94                         "on %s. Granting 0x%x\n",
  95                         smb_fname_str_dbg(smb_fname),
  96                         (unsigned int)access_mask ));
  97                 return NT_STATUS_OK;
  98         }
  99
 100         if ((access_mask & DELETE_ACCESS) && !lp_acl_check_permissions(SNUM(conn))) {
 101                 DEBUG(10,("smbd_check_access_rights: not checking ACL "
 102                         "on DELETE_ACCESS on file %s. Granting 0x%x\n",
 103                         smb_fname_str_dbg(smb_fname),
 104                         (unsigned int)access_mask ));
 105                 return NT_STATUS_OK;
 106         }
 107
 108         if (access_mask == DELETE_ACCESS &&
 109                         VALID_STAT(smb_fname->st) &&
 110                         S_ISLNK(smb_fname->st.st_ex_mode)) {
 111                 /* We can always delete a symlink. */
 112                 DEBUG(10,("smbd_check_access_rights: not checking ACL "
 113                         "on DELETE_ACCESS on symlink %s.\n",
 114                         smb_fname_str_dbg(smb_fname) ));
 115                 return NT_STATUS_OK;
 116         }
 117
 118         status = SMB_VFS_GET_NT_ACL(conn, smb_fname->base_name,
 119                         (SECINFO_OWNER |
 120                         SECINFO_GROUP |
 121                          SECINFO_DACL), talloc_tos(), &sd);
 122
 123         if (!NT_STATUS_IS_OK(status)) {
 124                 DEBUG(10, ("smbd_check_access_rights: Could not get acl "
 125                         "on %s: %s\n",
 126                         smb_fname_str_dbg(smb_fname),
 127                         nt_errstr(status)));
 128
 129                 if (NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED)) {
 130                         goto access_denied;
 131                 }
 132
 133                 return status;
 134         }
 135
 136         /*
 137          * If we can access the path to this file, by
 138          * default we have FILE_READ_ATTRIBUTES from the
 139          * containing directory. See the section:
 140          * "Algorithm to Check Access to an Existing File"
 141          * in MS-FSA.pdf.
 142          *
 143          * se_file_access_check() also takes care of
 144          * owner WRITE_DAC and READ_CONTROL.
 145          */
 146         status = se_file_access_check(sd,
 147                                 get_current_nttok(conn),
 148                                 use_privs,
 149                                 (access_mask & ~FILE_READ_ATTRIBUTES),
 150                                 &rejected_mask);
 151
 152         DEBUG(10,("smbd_check_access_rights: file %s requesting "
 153                 "0x%x returning 0x%x (%s)\n",
 154                 smb_fname_str_dbg(smb_fname),
 155                 (unsigned int)access_mask,
 156                 (unsigned int)rejected_mask,
 157                 nt_errstr(status) ));
 158
 159         if (!NT_STATUS_IS_OK(status)) {
 160                 if (DEBUGLEVEL >= 10) {
 161                         DEBUG(10,("smbd_check_access_rights: acl for %s is:\n",
 162                                 smb_fname_str_dbg(smb_fname) ));
 163                         NDR_PRINT_DEBUG(security_descriptor, sd);
 164                 }
 165         }
 166
 167         TALLOC_FREE(sd);
 168
 169         if (NT_STATUS_IS_OK(status) ||
 170                         !NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED)) {
 171                 return status;
 172         }
 173
 174         /* Here we know status == NT_STATUS_ACCESS_DENIED. */
 175
 176   access_denied:
 177
 178         if ((access_mask & FILE_WRITE_ATTRIBUTES) &&
 179                         (rejected_mask & FILE_WRITE_ATTRIBUTES) &&
 180                         !lp_store_dos_attributes(SNUM(conn)) &&
 181                         (lp_map_readonly(SNUM(conn)) ||
 182                         lp_map_archive(SNUM(conn)) ||
 183                         lp_map_hidden(SNUM(conn)) ||
 184                         lp_map_system(SNUM(conn)))) {
 185                 rejected_mask &= ~FILE_WRITE_ATTRIBUTES;
 186
 187                 DEBUG(10,("smbd_check_access_rights: "
 188                         "overrode "
 189                         "FILE_WRITE_ATTRIBUTES "
 190                         "on file %s\n",
 191                         smb_fname_str_dbg(smb_fname)));
 192         }
 193
 194         if (parent_override_delete(conn,
 195                                 smb_fname,
 196                                 access_mask,
 197                                 rejected_mask)) {
 198                 /* Were we trying to do an open
 199                  * for delete and didn't get DELETE
 200                  * access (only) ? Check if the
 201                  * directory allows DELETE_CHILD.
 202                  * See here:
 203                  * http://blogs.msdn.com/oldnewthing/archive/2004/06/04/148426.aspx
 204                  * for details. */
 205
 206                 rejected_mask &= ~DELETE_ACCESS;
 207
 208                 DEBUG(10,("smbd_check_access_rights: "
 209                         "overrode "
 210                         "DELETE_ACCESS on "
 211                         "file %s\n",
 212                         smb_fname_str_dbg(smb_fname)));
 213         }
 214
 215         if (rejected_mask != 0) {
 216                 return NT_STATUS_ACCESS_DENIED;
 217         }
 218         return NT_STATUS_OK;
 219 }
 220
 221 static NTSTATUS check_parent_access(struct connection_struct *conn,
 222                                 struct smb_filename *smb_fname,
 223                                 uint32_t access_mask)
 224 {
 225         NTSTATUS status;
 226         char *parent_dir = NULL;
 227         struct security_descriptor *parent_sd = NULL;
 228         uint32_t access_granted = 0;
 229
 230         if (!parent_dirname(talloc_tos(),
 231                                 smb_fname->base_name,
 232                                 &parent_dir,
 233                                 NULL)) {
 234                 return NT_STATUS_NO_MEMORY;
 235         }
 236
 237         if (get_current_uid(conn) == (uid_t)0) {
 238                 /* I'm sorry sir, I didn't know you were root... */
 239                 DEBUG(10,("check_parent_access: root override "
 240                         "on %s. Granting 0x%x\n",
 241                         smb_fname_str_dbg(smb_fname),
 242                         (unsigned int)access_mask ));
 243                 return NT_STATUS_OK;
 244         }
 245
 246         status = SMB_VFS_GET_NT_ACL(conn,
 247                                 parent_dir,
 248                                 SECINFO_DACL,
 249                                     talloc_tos(),
 250                                 &parent_sd);
 251
 252         if (!NT_STATUS_IS_OK(status)) {
 253                 DEBUG(5,("check_parent_access: SMB_VFS_GET_NT_ACL failed for "
 254                         "%s with error %s\n",
 255                         parent_dir,
 256                         nt_errstr(status)));
 257                 return status;
 258         }
 259
 260         /*
 261          * If we can access the path to this file, by
 262          * default we have FILE_READ_ATTRIBUTES from the
 263          * containing directory. See the section:
 264          * "Algorithm to Check Access to an Existing File"
 265          * in MS-FSA.pdf.
 266          *
 267          * se_file_access_check() also takes care of
 268          * owner WRITE_DAC and READ_CONTROL.
 269          */
 270         status = se_file_access_check(parent_sd,
 271                                 get_current_nttok(conn),
 272                                 false,
 273                                 (access_mask & ~FILE_READ_ATTRIBUTES),
 274                                 &access_granted);
 275         if(!NT_STATUS_IS_OK(status)) {
 276                 DEBUG(5,("check_parent_access: access check "
 277                         "on directory %s for "
 278                         "path %s for mask 0x%x returned (0x%x) %s\n",
 279                         parent_dir,
 280                         smb_fname->base_name,
 281                         access_mask,
 282                         access_granted,
 283                         nt_errstr(status) ));
 284                 return status;
 285         }
 286
 287         return NT_STATUS_OK;
 288 }
 289
 290 /****************************************************************************
 291  fd support routines - attempt to do a dos_open.
 292 ****************************************************************************/
 293
 294 NTSTATUS fd_open(struct connection_struct *conn,
 295                  files_struct *fsp,
 296                  int flags,
 297                  mode_t mode)
 298 {
 299         struct smb_filename *smb_fname = fsp->fsp_name;
 300         NTSTATUS status = NT_STATUS_OK;
 301
 302 #ifdef O_NOFOLLOW
 303         /*
 304          * Never follow symlinks on a POSIX client. The
 305          * client should be doing this.
 306          */
 307
 308         if (fsp->posix_open || !lp_symlinks(SNUM(conn))) {
 309                 flags |= O_NOFOLLOW;
 310         }
 311 #endif
 312
 313         fsp->fh->fd = SMB_VFS_OPEN(conn, smb_fname, fsp, flags, mode);
 314         if (fsp->fh->fd == -1) {
 315                 int posix_errno = errno;
 316 #ifdef O_NOFOLLOW
 317 #if defined(ENOTSUP) && defined(OSF1)
 318                 /* handle special Tru64 errno */
 319                 if (errno == ENOTSUP) {
 320                         posix_errno = ELOOP;
 321                 }
 322 #endif /* ENOTSUP */
 323 #ifdef EFTYPE
 324                 /* fix broken NetBSD errno */
 325                 if (errno == EFTYPE) {
 326                         posix_errno = ELOOP;
 327                 }
 328 #endif /* EFTYPE */
 329                 /* fix broken FreeBSD errno */
 330                 if (errno == EMLINK) {
 331                         posix_errno = ELOOP;
 332                 }
 333 #endif /* O_NOFOLLOW */
 334                 status = map_nt_error_from_unix(posix_errno);
 335                 if (errno == EMFILE) {
 336                         static time_t last_warned = 0L;
 337
 338                         if (time((time_t *) NULL) > last_warned) {
 339                                 DEBUG(0,("Too many open files, unable "
 340                                         "to open more!  smbd's max "
 341                                         "open files = %d\n",
 342                                         lp_max_open_files()));
 343                                 last_warned = time((time_t *) NULL);
 344                         }
 345                 }
 346
 347         }
 348
 349         DEBUG(10,("fd_open: name %s, flags = 0%o mode = 0%o, fd = %d. %s\n",
 350                   smb_fname_str_dbg(smb_fname), flags, (int)mode, fsp->fh->fd,
 351                 (fsp->fh->fd == -1) ? strerror(errno) : "" ));
 352
 353         return status;
 354 }
 355
 356 /****************************************************************************
 357  Close the file associated with a fsp.
 358 ****************************************************************************/
 359
 360 NTSTATUS fd_close(files_struct *fsp)
 361 {
 362         int ret;
 363
 364         if (fsp->dptr) {
 365                 dptr_CloseDir(fsp);
 366         }
 367         if (fsp->fh->fd == -1) {
 368                 return NT_STATUS_OK; /* What we used to call a stat open. */
 369         }
 370         if (fsp->fh->ref_count > 1) {
 371                 return NT_STATUS_OK; /* Shared handle. Only close last reference. */
 372         }
 373
 374         ret = SMB_VFS_CLOSE(fsp);
 375         fsp->fh->fd = -1;
 376         if (ret == -1) {
 377                 return map_nt_error_from_unix(errno);
 378         }
 379         return NT_STATUS_OK;
 380 }
 381
 382 /****************************************************************************
 383  Change the ownership of a file to that of the parent directory.
 384  Do this by fd if possible.
 385 ****************************************************************************/
 386
 387 void change_file_owner_to_parent(connection_struct *conn,
 388                                         const char *inherit_from_dir,
 389                                         files_struct *fsp)
 390 {
 391         struct smb_filename *smb_fname_parent;
 392         int ret;
 393
 394         smb_fname_parent = synthetic_smb_fname(talloc_tos(), inherit_from_dir,
 395                                                NULL, NULL);
 396         if (smb_fname_parent == NULL) {
 397                 return;
 398         }
 399
 400         ret = SMB_VFS_STAT(conn, smb_fname_parent);
 401         if (ret == -1) {
 402                 DEBUG(0,("change_file_owner_to_parent: failed to stat parent "
 403                          "directory %s. Error was %s\n",
 404                          smb_fname_str_dbg(smb_fname_parent),
 405                          strerror(errno)));
 406                 TALLOC_FREE(smb_fname_parent);
 407                 return;
 408         }
 409
 410         if (smb_fname_parent->st.st_ex_uid == fsp->fsp_name->st.st_ex_uid) {
 411                 /* Already this uid - no need to change. */
 412                 DEBUG(10,("change_file_owner_to_parent: file %s "
 413                         "is already owned by uid %d\n",
 414                         fsp_str_dbg(fsp),
 415                         (int)fsp->fsp_name->st.st_ex_uid ));
 416                 TALLOC_FREE(smb_fname_parent);
 417                 return;
 418         }
 419
 420         become_root();
 421         ret = SMB_VFS_FCHOWN(fsp, smb_fname_parent->st.st_ex_uid, (gid_t)-1);
 422         unbecome_root();
 423         if (ret == -1) {
 424                 DEBUG(0,("change_file_owner_to_parent: failed to fchown "
 425                          "file %s to parent directory uid %u. Error "
 426                          "was %s\n", fsp_str_dbg(fsp),
 427                          (unsigned int)smb_fname_parent->st.st_ex_uid,
 428                          strerror(errno) ));
 429         } else {
 430                 DEBUG(10,("change_file_owner_to_parent: changed new file %s to "
 431                         "parent directory uid %u.\n", fsp_str_dbg(fsp),
 432                         (unsigned int)smb_fname_parent->st.st_ex_uid));
 433                 /* Ensure the uid entry is updated. */
 434                 fsp->fsp_name->st.st_ex_uid = smb_fname_parent->st.st_ex_uid;
 435         }
 436
 437         TALLOC_FREE(smb_fname_parent);
 438 }
 439
 440 NTSTATUS change_dir_owner_to_parent(connection_struct *conn,
 441                                        const char *inherit_from_dir,
 442                                        const char *fname,
 443                                        SMB_STRUCT_STAT *psbuf)
 444 {
 445         struct smb_filename *smb_fname_parent;
 446         struct smb_filename *smb_fname_cwd = NULL;
 447         char *saved_dir = NULL;
 448         TALLOC_CTX *ctx = talloc_tos();
 449         NTSTATUS status = NT_STATUS_OK;
 450         int ret;
 451
 452         smb_fname_parent = synthetic_smb_fname(ctx, inherit_from_dir,
 453                                                NULL, NULL);
 454         if (smb_fname_parent == NULL) {
 455                 return NT_STATUS_NO_MEMORY;
 456         }
 457
 458         ret = SMB_VFS_STAT(conn, smb_fname_parent);
 459         if (ret == -1) {
 460                 status = map_nt_error_from_unix(errno);
 461                 DEBUG(0,("change_dir_owner_to_parent: failed to stat parent "
 462                          "directory %s. Error was %s\n",
 463                          smb_fname_str_dbg(smb_fname_parent),
 464                          strerror(errno)));
 465                 goto out;
 466         }
 467
 468         /* We've already done an lstat into psbuf, and we know it's a
 469            directory. If we can cd into the directory and the dev/ino
 470            are the same then we can safely chown without races as
 471            we're locking the directory in place by being in it.  This
 472            should work on any UNIX (thanks tridge :-). JRA.
 473         */
 474
 475         saved_dir = vfs_GetWd(ctx,conn);
 476         if (!saved_dir) {
 477                 status = map_nt_error_from_unix(errno);
 478                 DEBUG(0,("change_dir_owner_to_parent: failed to get "
 479                          "current working directory. Error was %s\n",
 480                          strerror(errno)));
 481                 goto out;
 482         }
 483
 484         /* Chdir into the new path. */
 485         if (vfs_ChDir(conn, fname) == -1) {
 486                 status = map_nt_error_from_unix(errno);
 487                 DEBUG(0,("change_dir_owner_to_parent: failed to change "
 488                          "current working directory to %s. Error "
 489                          "was %s\n", fname, strerror(errno) ));
 490                 goto chdir;
 491         }
 492
 493         smb_fname_cwd = synthetic_smb_fname(ctx, ".", NULL, NULL);
 494         if (smb_fname_cwd == NULL) {
 495                 status = NT_STATUS_NO_MEMORY;
 496                 goto chdir;
 497         }
 498
 499         ret = SMB_VFS_STAT(conn, smb_fname_cwd);
 500         if (ret == -1) {
 501                 status = map_nt_error_from_unix(errno);
 502                 DEBUG(0,("change_dir_owner_to_parent: failed to stat "
 503                          "directory '.' (%s) Error was %s\n",
 504                          fname, strerror(errno)));
 505                 goto chdir;
 506         }
 507
 508         /* Ensure we're pointing at the same place. */
 509         if (smb_fname_cwd->st.st_ex_dev != psbuf->st_ex_dev ||
 510             smb_fname_cwd->st.st_ex_ino != psbuf->st_ex_ino) {
 511                 DEBUG(0,("change_dir_owner_to_parent: "
 512                          "device/inode on directory %s changed. "
 513                          "Refusing to chown !\n", fname ));
 514                 status = NT_STATUS_ACCESS_DENIED;
 515                 goto chdir;
 516         }
 517
 518         if (smb_fname_parent->st.st_ex_uid == smb_fname_cwd->st.st_ex_uid) {
 519                 /* Already this uid - no need to change. */
 520                 DEBUG(10,("change_dir_owner_to_parent: directory %s "
 521                         "is already owned by uid %d\n",
 522                         fname,
 523                         (int)smb_fname_cwd->st.st_ex_uid ));
 524                 status = NT_STATUS_OK;
 525                 goto chdir;
 526         }
 527
 528         become_root();
 529         ret = SMB_VFS_LCHOWN(conn, ".", smb_fname_parent->st.st_ex_uid,
 530                             (gid_t)-1);
 531         unbecome_root();
 532         if (ret == -1) {
 533                 status = map_nt_error_from_unix(errno);
 534                 DEBUG(10,("change_dir_owner_to_parent: failed to chown "
 535                           "directory %s to parent directory uid %u. "
 536                           "Error was %s\n", fname,
 537                           (unsigned int)smb_fname_parent->st.st_ex_uid,
 538                           strerror(errno) ));
 539         } else {
 540                 DEBUG(10,("change_dir_owner_to_parent: changed ownership of new "
 541                         "directory %s to parent directory uid %u.\n",
 542                         fname, (unsigned int)smb_fname_parent->st.st_ex_uid ));
 543                 /* Ensure the uid entry is updated. */
 544                 psbuf->st_ex_uid = smb_fname_parent->st.st_ex_uid;
 545         }
 546
 547  chdir:
 548         vfs_ChDir(conn,saved_dir);
 549  out:
 550         TALLOC_FREE(smb_fname_parent);
 551         TALLOC_FREE(smb_fname_cwd);
 552         return status;
 553 }
 554
 555 /****************************************************************************
 556  Open a file - returning a guaranteed ATOMIC indication of if the
 557  file was created or not.
 558 ****************************************************************************/
 559
 560 static NTSTATUS fd_open_atomic(struct connection_struct *conn,
 561                         files_struct *fsp,
 562                         int flags,
 563                         mode_t mode,
 564                         bool *file_created)
 565 {
 566         NTSTATUS status = NT_STATUS_UNSUCCESSFUL;
 567         bool file_existed = VALID_STAT(fsp->fsp_name->st);
 568
 569         *file_created = false;
 570
 571         if (!(flags & O_CREAT)) {
 572                 /*
 573                  * We're not creating the file, just pass through.
 574                  */
 575                 return fd_open(conn, fsp, flags, mode);
 576         }
 577
 578         if (flags & O_EXCL) {
 579                 /*
 580                  * Fail if already exists, just pass through.
 581                  */
 582                 status = fd_open(conn, fsp, flags, mode);
 583
 584                 /*
 585                  * Here we've opened with O_CREAT|O_EXCL. If that went
 586                  * NT_STATUS_OK, we *know* we created this file.
 587                  */
 588                 *file_created = NT_STATUS_IS_OK(status);
 589
 590                 return status;
 591         }
 592
 593         /*
 594          * Now it gets tricky. We have O_CREAT, but not O_EXCL.
 595          * To know absolutely if we created the file or not,
 596          * we can never call O_CREAT without O_EXCL. So if
 597          * we think the file existed, try without O_CREAT|O_EXCL.
 598          * If we think the file didn't exist, try with
 599          * O_CREAT|O_EXCL. Keep bouncing between these two
 600          * requests until either the file is created, or
 601          * opened. Either way, we keep going until we get
 602          * a returnable result (error, or open/create).
 603          */
 604
 605         while(1) {
 606                 int curr_flags = flags;
 607
 608                 if (file_existed) {
 609                         /* Just try open, do not create. */
 610                         curr_flags &= ~(O_CREAT);
 611                         status = fd_open(conn, fsp, curr_flags, mode);
 612                         if (NT_STATUS_EQUAL(status,
 613                                         NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
 614                                 /*
 615                                  * Someone deleted it in the meantime.
 616                                  * Retry with O_EXCL.
 617                                  */
 618                                 file_existed = false;
 619                                 DEBUG(10,("fd_open_atomic: file %s existed. "
 620                                         "Retry.\n",
 621                                         smb_fname_str_dbg(fsp->fsp_name)));
 622                                         continue;
 623                         }
 624                 } else {
 625                         /* Try create exclusively, fail if it exists. */
 626                         curr_flags |= O_EXCL;
 627                         status = fd_open(conn, fsp, curr_flags, mode);
 628                         if (NT_STATUS_EQUAL(status,
 629                                         NT_STATUS_OBJECT_NAME_COLLISION)) {
 630                                 /*
 631                                  * Someone created it in the meantime.
 632                                  * Retry without O_CREAT.
 633                                  */
 634                                 file_existed = true;
 635                                 DEBUG(10,("fd_open_atomic: file %s "
 636                                         "did not exist. Retry.\n",
 637                                         smb_fname_str_dbg(fsp->fsp_name)));
 638                                 continue;
 639                         }
 640                         if (NT_STATUS_IS_OK(status)) {
 641                                 /*
 642                                  * Here we've opened with O_CREAT|O_EXCL
 643                                  * and got success. We *know* we created
 644                                  * this file.
 645                                  */
 646                                 *file_created = true;
 647                         }
 648                 }
 649                 /* Create is done, or failed. */
 650                 break;
 651         }
 652         return status;
 653 }
 654
 655 /****************************************************************************
 656  Open a file.
 657 ****************************************************************************/
 658
 659 static NTSTATUS open_file(files_struct *fsp,
 660                           connection_struct *conn,
 661                           struct smb_request *req,
 662                           const char *parent_dir,
 663                           int flags,
 664                           mode_t unx_mode,
 665                           uint32 access_mask, /* client requested access mask. */
 666                           uint32 open_access_mask, /* what we're actually using in the open. */
 667                           bool *p_file_created)
 668 {
 669         struct smb_filename *smb_fname = fsp->fsp_name;
 670         NTSTATUS status = NT_STATUS_OK;
 671         int accmode = (flags & O_ACCMODE);
 672         int local_flags = flags;
 673         bool file_existed = VALID_STAT(fsp->fsp_name->st);
 674
 675         fsp->fh->fd = -1;
 676         errno = EPERM;
 677
 678         /* Check permissions */
 679
 680         /*
 681          * This code was changed after seeing a client open request
 682          * containing the open mode of (DENY_WRITE/read-only) with
 683          * the 'create if not exist' bit set. The previous code
 684          * would fail to open the file read only on a read-only share
 685          * as it was checking the flags parameter  directly against O_RDONLY,
 686          * this was failing as the flags parameter was set to O_RDONLY|O_CREAT.
 687          * JRA.
 688          */
 689
 690         if (!CAN_WRITE(conn)) {
 691                 /* It's a read-only share - fail if we wanted to write. */
 692                 if(accmode != O_RDONLY || (flags & O_TRUNC) || (flags & O_APPEND)) {
 693                         DEBUG(3,("Permission denied opening %s\n",
 694                                  smb_fname_str_dbg(smb_fname)));
 695                         return NT_STATUS_ACCESS_DENIED;
 696                 }
 697                 if (flags & O_CREAT) {
 698                         /* We don't want to write - but we must make sure that
 699                            O_CREAT doesn't create the file if we have write
 700                            access into the directory.
 701                         */
 702                         flags &= ~(O_CREAT|O_EXCL);
 703                         local_flags &= ~(O_CREAT|O_EXCL);
 704                 }
 705         }
 706
 707         /*
 708          * This little piece of insanity is inspired by the
 709          * fact that an NT client can open a file for O_RDONLY,
 710          * but set the create disposition to FILE_EXISTS_TRUNCATE.
 711          * If the client *can* write to the file, then it expects to
 712          * truncate the file, even though it is opening for readonly.
 713          * Quicken uses this stupid trick in backup file creation...
 714          * Thanks *greatly* to "David W. Chapman Jr." <dwcjr@inethouston.net>
 715          * for helping track this one down. It didn't bite us in 2.0.x
 716          * as we always opened files read-write in that release. JRA.
 717          */
 718
 719         if ((accmode == O_RDONLY) && ((flags & O_TRUNC) == O_TRUNC)) {
 720                 DEBUG(10,("open_file: truncate requested on read-only open "
 721                           "for file %s\n", smb_fname_str_dbg(smb_fname)));
 722                 local_flags = (flags & ~O_ACCMODE)|O_RDWR;
 723         }
 724
 725         if ((open_access_mask & (FILE_READ_DATA|FILE_WRITE_DATA|FILE_APPEND_DATA|FILE_EXECUTE)) ||
 726             (!file_existed && (local_flags & O_CREAT)) ||
 727             ((local_flags & O_TRUNC) == O_TRUNC) ) {
 728                 const char *wild;
 729                 int ret;
 730
 731 #if defined(O_NONBLOCK) && defined(S_ISFIFO)
 732                 /*
 733                  * We would block on opening a FIFO with no one else on the
 734                  * other end. Do what we used to do and add O_NONBLOCK to the
 735                  * open flags. JRA.
 736                  */
 737
 738                 if (file_existed && S_ISFIFO(smb_fname->st.st_ex_mode)) {
 739                         local_flags &= ~O_TRUNC; /* Can't truncate a FIFO. */
 740                         local_flags |= O_NONBLOCK;
 741                 }
 742 #endif
 743
 744                 /* Don't create files with Microsoft wildcard characters. */
 745                 if (fsp->base_fsp) {
 746                         /*
 747                          * wildcard characters are allowed in stream names
 748                          * only test the basefilename
 749                          */
 750                         wild = fsp->base_fsp->fsp_name->base_name;
 751                 } else {
 752                         wild = smb_fname->base_name;
 753                 }
 754                 if ((local_flags & O_CREAT) && !file_existed &&
 755                     ms_has_wild(wild))  {
 756                         return NT_STATUS_OBJECT_NAME_INVALID;
 757                 }
 758
 759                 /* Can we access this file ? */
 760                 if (!fsp->base_fsp) {
 761                         /* Only do this check on non-stream open. */
 762                         if (file_existed) {
 763                                 status = smbd_check_access_rights(conn,
 764                                                 smb_fname,
 765                                                 false,
 766                                                 access_mask);
 767                         } else if (local_flags & O_CREAT){
 768                                 status = check_parent_access(conn,
 769                                                 smb_fname,
 770                                                 SEC_DIR_ADD_FILE);
 771                         } else {
 772                                 /* File didn't exist and no O_CREAT. */
 773                                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
 774                         }
 775                         if (!NT_STATUS_IS_OK(status)) {
 776                                 DEBUG(10,("open_file: "
 777                                         "%s on file "
 778                                         "%s returned %s\n",
 779                                         file_existed ?
 780                                                 "smbd_check_access_rights" :
 781                                                 "check_parent_access",
 782                                         smb_fname_str_dbg(smb_fname),
 783                                         nt_errstr(status) ));
 784                                 return status;
 785                         }
 786                 }
 787
 788                 /* Actually do the open */
 789                 status = fd_open_atomic(conn, fsp, local_flags,
 790                                 unx_mode, p_file_created);
 791                 if (!NT_STATUS_IS_OK(status)) {
 792                         DEBUG(3,("Error opening file %s (%s) (local_flags=%d) "
 793                                  "(flags=%d)\n", smb_fname_str_dbg(smb_fname),
 794                                  nt_errstr(status),local_flags,flags));
 795                         return status;
 796                 }
 797
 798                 ret = SMB_VFS_FSTAT(fsp, &smb_fname->st);
 799                 if (ret == -1) {
 800                         /* If we have an fd, this stat should succeed. */
 801                         DEBUG(0,("Error doing fstat on open file %s "
 802                                 "(%s)\n",
 803                                 smb_fname_str_dbg(smb_fname),
 804                                 strerror(errno) ));
 805                         status = map_nt_error_from_unix(errno);
 806                         fd_close(fsp);
 807                         return status;
 808                 }
 809
 810                 if (*p_file_created) {
 811                         /* We created this file. */
 812
 813                         bool need_re_stat = false;
 814                         /* Do all inheritance work after we've
 815                            done a successful fstat call and filled
 816                            in the stat struct in fsp->fsp_name. */
 817
 818                         /* Inherit the ACL if required */
 819                         if (lp_inherit_perms(SNUM(conn))) {
 820                                 inherit_access_posix_acl(conn, parent_dir,
 821                                                          smb_fname->base_name,
 822                                                          unx_mode);
 823                                 need_re_stat = true;
 824                         }
 825
 826                         /* Change the owner if required. */
 827                         if (lp_inherit_owner(SNUM(conn))) {
 828                                 change_file_owner_to_parent(conn, parent_dir,
 829                                                             fsp);
 830                                 need_re_stat = true;
 831                         }
 832
 833                         if (need_re_stat) {
 834                                 ret = SMB_VFS_FSTAT(fsp, &smb_fname->st);
 835                                 /* If we have an fd, this stat should succeed. */
 836                                 if (ret == -1) {
 837                                         DEBUG(0,("Error doing fstat on open file %s "
 838                                                  "(%s)\n",
 839                                                  smb_fname_str_dbg(smb_fname),
 840                                                  strerror(errno) ));
 841                                 }
 842                         }
 843
 844                         notify_fname(conn, NOTIFY_ACTION_ADDED,
 845                                      FILE_NOTIFY_CHANGE_FILE_NAME,
 846                                      smb_fname->base_name);
 847                 }
 848         } else {
 849                 fsp->fh->fd = -1; /* What we used to call a stat open. */
 850                 if (!file_existed) {
 851                         /* File must exist for a stat open. */
 852                         return NT_STATUS_OBJECT_NAME_NOT_FOUND;
 853                 }
 854
 855                 status = smbd_check_access_rights(conn,
 856                                 smb_fname,
 857                                 false,
 858                                 access_mask);
 859
 860                 if (NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND) &&
 861                                 fsp->posix_open &&
 862                                 S_ISLNK(smb_fname->st.st_ex_mode)) {
 863                         /* This is a POSIX stat open for delete
 864                          * or rename on a symlink that points
 865                          * nowhere. Allow. */
 866                         DEBUG(10,("open_file: allowing POSIX "
 867                                   "open on bad symlink %s\n",
 868                                   smb_fname_str_dbg(smb_fname)));
 869                         status = NT_STATUS_OK;
 870                 }
 871
 872                 if (!NT_STATUS_IS_OK(status)) {
 873                         DEBUG(10,("open_file: "
 874                                 "smbd_check_access_rights on file "
 875                                 "%s returned %s\n",
 876                                 smb_fname_str_dbg(smb_fname),
 877                                 nt_errstr(status) ));
 878                         return status;
 879                 }
 880         }
 881
 882         /*
 883          * POSIX allows read-only opens of directories. We don't
 884          * want to do this (we use a different code path for this)
 885          * so catch a directory open and return an EISDIR. JRA.
 886          */
 887
 888         if(S_ISDIR(smb_fname->st.st_ex_mode)) {
 889                 fd_close(fsp);
 890                 errno = EISDIR;
 891                 return NT_STATUS_FILE_IS_A_DIRECTORY;
 892         }
 893
 894         fsp->file_id = vfs_file_id_from_sbuf(conn, &smb_fname->st);
 895         fsp->vuid = req ? req->vuid : UID_FIELD_INVALID;
 896         fsp->file_pid = req ? req->smbpid : 0;
 897         fsp->can_lock = True;
 898         fsp->can_read = ((access_mask & FILE_READ_DATA) != 0);
 899         fsp->can_write =
 900                 CAN_WRITE(conn) &&
 901                 ((access_mask & (FILE_WRITE_DATA | FILE_APPEND_DATA)) != 0);
 902         fsp->print_file = NULL;
 903         fsp->modified = False;
 904         fsp->sent_oplock_break = NO_BREAK_SENT;
 905         fsp->is_directory = False;
 906         if (conn->aio_write_behind_list &&
 907             is_in_path(smb_fname->base_name, conn->aio_write_behind_list,
 908                        conn->case_sensitive)) {
 909                 fsp->aio_write_behind = True;
 910         }
 911
 912         fsp->wcp = NULL; /* Write cache pointer. */
 913
 914         DEBUG(2,("%s opened file %s read=%s write=%s (numopen=%d)\n",
 915                  conn->session_info->unix_info->unix_name,
 916                  smb_fname_str_dbg(smb_fname),
 917                  BOOLSTR(fsp->can_read), BOOLSTR(fsp->can_write),
 918                  conn->num_files_open));
 919
 920         errno = 0;
 921         return NT_STATUS_OK;
 922 }
 923
 924 /****************************************************************************
 925  Check if we can open a file with a share mode.
 926  Returns True if conflict, False if not.
 927 ****************************************************************************/
 928
 929 static bool share_conflict(struct share_mode_entry *entry,
 930                            uint32 access_mask,
 931                            uint32 share_access)
 932 {
 933         DEBUG(10,("share_conflict: entry->access_mask = 0x%x, "
 934                   "entry->share_access = 0x%x, "
 935                   "entry->private_options = 0x%x\n",
 936                   (unsigned int)entry->access_mask,
 937                   (unsigned int)entry->share_access,
 938                   (unsigned int)entry->private_options));
 939
 940         if (server_id_is_disconnected(&entry->pid)) {
 941                 /*
 942                  * note: cleanup should have been done by
 943                  * delay_for_batch_oplocks()
 944                  */
 945                 return false;
 946         }
 947
 948         DEBUG(10,("share_conflict: access_mask = 0x%x, share_access = 0x%x\n",
 949                   (unsigned int)access_mask, (unsigned int)share_access));
 950
 951         if ((entry->access_mask & (FILE_WRITE_DATA|
 952                                    FILE_APPEND_DATA|
 953                                    FILE_READ_DATA|
 954                                    FILE_EXECUTE|
 955                                    DELETE_ACCESS)) == 0) {
 956                 DEBUG(10,("share_conflict: No conflict due to "
 957                           "entry->access_mask = 0x%x\n",
 958                           (unsigned int)entry->access_mask ));
 959                 return False;
 960         }
 961
 962         if ((access_mask & (FILE_WRITE_DATA|
 963                             FILE_APPEND_DATA|
 964                             FILE_READ_DATA|
 965                             FILE_EXECUTE|
 966                             DELETE_ACCESS)) == 0) {
 967                 DEBUG(10,("share_conflict: No conflict due to "
 968                           "access_mask = 0x%x\n",
 969                           (unsigned int)access_mask ));
 970                 return False;
 971         }
 972
 973 #if 1 /* JRA TEST - Superdebug. */
 974 #define CHECK_MASK(num, am, right, sa, share) \
 975         DEBUG(10,("share_conflict: [%d] am (0x%x) & right (0x%x) = 0x%x\n", \
 976                 (unsigned int)(num), (unsigned int)(am), \
 977                 (unsigned int)(right), (unsigned int)(am)&(right) )); \
 978         DEBUG(10,("share_conflict: [%d] sa (0x%x) & share (0x%x) = 0x%x\n", \
 979                 (unsigned int)(num), (unsigned int)(sa), \
 980                 (unsigned int)(share), (unsigned int)(sa)&(share) )); \
 981         if (((am) & (right)) && !((sa) & (share))) { \
 982                 DEBUG(10,("share_conflict: check %d conflict am = 0x%x, right = 0x%x, \
 983 sa = 0x%x, share = 0x%x\n", (num), (unsigned int)(am), (unsigned int)(right), (unsigned int)(sa), \
 984                         (unsigned int)(share) )); \
 985                 return True; \
 986         }
 987 #else
 988 #define CHECK_MASK(num, am, right, sa, share) \
 989         if (((am) & (right)) && !((sa) & (share))) { \
 990                 DEBUG(10,("share_conflict: check %d conflict am = 0x%x, right = 0x%x, \
 991 sa = 0x%x, share = 0x%x\n", (num), (unsigned int)(am), (unsigned int)(right), (unsigned int)(sa), \
 992                         (unsigned int)(share) )); \
 993                 return True; \
 994         }
 995 #endif
 996
 997         CHECK_MASK(1, entry->access_mask, FILE_WRITE_DATA | FILE_APPEND_DATA,
 998                    share_access, FILE_SHARE_WRITE);
 999         CHECK_MASK(2, access_mask, FILE_WRITE_DATA | FILE_APPEND_DATA,
1000                    entry->share_access, FILE_SHARE_WRITE);
1001
1002         CHECK_MASK(3, entry->access_mask, FILE_READ_DATA | FILE_EXECUTE,
1003                    share_access, FILE_SHARE_READ);
1004         CHECK_MASK(4, access_mask, FILE_READ_DATA | FILE_EXECUTE,
1005                    entry->share_access, FILE_SHARE_READ);
1006
1007         CHECK_MASK(5, entry->access_mask, DELETE_ACCESS,
1008                    share_access, FILE_SHARE_DELETE);
1009         CHECK_MASK(6, access_mask, DELETE_ACCESS,
1010                    entry->share_access, FILE_SHARE_DELETE);
1011
1012         DEBUG(10,("share_conflict: No conflict.\n"));
1013         return False;
1014 }
1015
1016 #if defined(DEVELOPER)
1017 static void validate_my_share_entries(struct smbd_server_connection *sconn,
1018                                       int num,
1019                                       struct share_mode_entry *share_entry)
1020 {
1021         struct server_id self = messaging_server_id(sconn->msg_ctx);
1022         files_struct *fsp;
1023
1024         if (!serverid_equal(&self, &share_entry->pid)) {
1025                 return;
1026         }
1027
1028         if (!is_valid_share_mode_entry(share_entry)) {
1029                 return;
1030         }
1031
1032         fsp = file_find_dif(sconn, share_entry->id,
1033                             share_entry->share_file_id);
1034         if (!fsp) {
1035                 DEBUG(0,("validate_my_share_entries: PANIC : %s\n",
1036                          share_mode_str(talloc_tos(), num, share_entry) ));
1037                 smb_panic("validate_my_share_entries: Cannot match a "
1038                           "share entry with an open file\n");
1039         }
1040
1041         if ((share_entry->op_type == NO_OPLOCK) &&
1042             (fsp->oplock_type == FAKE_LEVEL_II_OPLOCK))
1043         {
1044                 /* Someone has already written to it, but I haven't yet
1045                  * noticed */
1046                 return;
1047         }
1048
1049         if (((uint16)fsp->oplock_type) != share_entry->op_type) {
1050                 goto panic;
1051         }
1052
1053         return;
1054
1055  panic:
1056         {
1057                 char *str;
1058                 DEBUG(0,("validate_my_share_entries: PANIC : %s\n",
1059                          share_mode_str(talloc_tos(), num, share_entry) ));
1060                 str = talloc_asprintf(talloc_tos(),
1061                         "validate_my_share_entries: "
1062                         "file %s, oplock_type = 0x%x, op_type = 0x%x\n",
1063                          fsp->fsp_name->base_name,
1064                          (unsigned int)fsp->oplock_type,
1065                          (unsigned int)share_entry->op_type );
1066                 smb_panic(str);
1067         }
1068 }
1069 #endif
1070
1071 bool is_stat_open(uint32 access_mask)
1072 {
1073         const uint32_t stat_open_bits =
1074                 (SYNCHRONIZE_ACCESS|
1075                  FILE_READ_ATTRIBUTES|
1076                  FILE_WRITE_ATTRIBUTES);
1077
1078         return (((access_mask &  stat_open_bits) != 0) &&
1079                 ((access_mask & ~stat_open_bits) == 0));
1080 }
1081
1082 /****************************************************************************
1083  Deal with share modes
1084  Invarient: Share mode must be locked on entry and exit.
1085  Returns -1 on error, or number of share modes on success (may be zero).
1086 ****************************************************************************/
1087
1088 static NTSTATUS open_mode_check(connection_struct *conn,
1089                                 struct share_mode_lock *lck,
1090                                 uint32_t name_hash,
1091                                 uint32 access_mask,
1092                                 uint32 share_access,
1093                                 uint32 create_options,
1094                                 bool *file_existed)
1095 {
1096         int i;
1097
1098         if(lck->data->num_share_modes == 0) {
1099                 return NT_STATUS_OK;
1100         }
1101
1102         /* A delete on close prohibits everything */
1103
1104         if (is_delete_on_close_set(lck, name_hash)) {
1105                 /*
1106                  * Check the delete on close token
1107                  * is valid. It could have been left
1108                  * after a server crash.
1109                  */
1110                 for(i = 0; i < lck->data->num_share_modes; i++) {
1111                         if (!share_mode_stale_pid(lck->data, i)) {
1112
1113                                 *file_existed = true;
1114
1115                                 return NT_STATUS_DELETE_PENDING;
1116                         }
1117                 }
1118                 return NT_STATUS_OK;
1119         }
1120
1121         if (is_stat_open(access_mask)) {
1122                 /* Stat open that doesn't trigger oplock breaks or share mode
1123                  * checks... ! JRA. */
1124                 return NT_STATUS_OK;
1125         }
1126
1127         /*
1128          * Check if the share modes will give us access.
1129          */
1130
1131 #if defined(DEVELOPER)
1132         for(i = 0; i < lck->data->num_share_modes; i++) {
1133                 validate_my_share_entries(conn->sconn, i,
1134                                           &lck->data->share_modes[i]);
1135         }
1136 #endif
1137
1138         /* Now we check the share modes, after any oplock breaks. */
1139         for(i = 0; i < lck->data->num_share_modes; i++) {
1140
1141                 if (!is_valid_share_mode_entry(&lck->data->share_modes[i])) {
1142                         continue;
1143                 }
1144
1145                 /* someone else has a share lock on it, check to see if we can
1146                  * too */
1147                 if (share_conflict(&lck->data->share_modes[i],
1148                                    access_mask, share_access)) {
1149
1150                         if (share_mode_stale_pid(lck->data, i)) {
1151                                 continue;
1152                         }
1153
1154                         *file_existed = true;
1155
1156                         return NT_STATUS_SHARING_VIOLATION;
1157                 }
1158         }
1159
1160         if (lck->data->num_share_modes != 0) {
1161                 *file_existed = true;
1162         }
1163
1164         return NT_STATUS_OK;
1165 }
1166
1167 /*
1168  * Send a break message to the oplock holder and delay the open for
1169  * our client.
1170  */
1171
1172 static NTSTATUS send_break_message(files_struct *fsp,
1173                                         struct share_mode_entry *exclusive,
1174                                         uint64_t mid,
1175                                         int oplock_request)
1176 {
1177         NTSTATUS status;
1178         char msg[MSG_SMB_SHARE_MODE_ENTRY_SIZE];
1179
1180         DEBUG(10, ("Sending break request to PID %s\n",
1181                    procid_str_static(&exclusive->pid)));
1182         exclusive->op_mid = mid;
1183
1184         /* Create the message. */
1185         share_mode_entry_to_message(msg, exclusive);
1186
1187         /* Add in the FORCE_OPLOCK_BREAK_TO_NONE bit in the message if set. We
1188            don't want this set in the share mode struct pointed to by lck. */
1189
1190         if (oplock_request & FORCE_OPLOCK_BREAK_TO_NONE) {
1191                 SSVAL(msg,OP_BREAK_MSG_OP_TYPE_OFFSET,
1192                         exclusive->op_type | FORCE_OPLOCK_BREAK_TO_NONE);
1193         }
1194
1195         status = messaging_send_buf(fsp->conn->sconn->msg_ctx, exclusive->pid,
1196                                     MSG_SMB_BREAK_REQUEST,
1197                                     (uint8 *)msg,
1198                                     MSG_SMB_SHARE_MODE_ENTRY_SIZE);
1199         if (!NT_STATUS_IS_OK(status)) {
1200                 DEBUG(3, ("Could not send oplock break message: %s\n",
1201                           nt_errstr(status)));
1202         }
1203
1204         return status;
1205 }
1206
1207 /*
1208  * Return share_mode_entry pointers for :
1209  * 1). Batch oplock entry.
1210  * 2). Batch or exclusive oplock entry (may be identical to #1).
1211  * bool have_level2_oplock
1212  * bool have_no_oplock.
1213  * Do internal consistency checks on the share mode for a file.
1214  */
1215
1216 static void find_oplock_types(files_struct *fsp,
1217                                 int oplock_request,
1218                                 const struct share_mode_lock *lck,
1219                                 struct share_mode_entry **pp_batch,
1220                                 struct share_mode_entry **pp_ex_or_batch,
1221                                 bool *got_level2,
1222                                 bool *got_no_oplock)
1223 {
1224         int i;
1225
1226         *pp_batch = NULL;
1227         *pp_ex_or_batch = NULL;
1228         *got_level2 = false;
1229         *got_no_oplock = false;
1230
1231         /* Ignore stat or internal opens, as is done in
1232                 delay_for_batch_oplocks() and
1233                 delay_for_exclusive_oplocks().
1234          */
1235         if ((oplock_request & INTERNAL_OPEN_ONLY) || is_stat_open(fsp->access_mask)) {
1236                 return;
1237         }
1238
1239         for (i=0; i<lck->data->num_share_modes; i++) {
1240                 if (!is_valid_share_mode_entry(&lck->data->share_modes[i])) {
1241                         continue;
1242                 }
1243
1244                 if (lck->data->share_modes[i].op_type == NO_OPLOCK &&
1245                                 is_stat_open(lck->data->share_modes[i].access_mask)) {
1246                         /* We ignore stat opens in the table - they
1247                            always have NO_OPLOCK and never get or
1248                            cause breaks. JRA. */
1249                         continue;
1250                 }
1251
1252                 if (BATCH_OPLOCK_TYPE(lck->data->share_modes[i].op_type)) {
1253                         /* batch - can only be one. */
1254                         if (share_mode_stale_pid(lck->data, i)) {
1255                                 DEBUG(10, ("Found stale batch oplock\n"));
1256                                 continue;
1257                         }
1258                         if (*pp_ex_or_batch || *pp_batch || *got_level2 || *got_no_oplock) {
1259                                 smb_panic("Bad batch oplock entry.");
1260                         }
1261                         *pp_batch = &lck->data->share_modes[i];
1262                 }
1263
1264                 if (EXCLUSIVE_OPLOCK_TYPE(lck->data->share_modes[i].op_type)) {
1265                         if (share_mode_stale_pid(lck->data, i)) {
1266                                 DEBUG(10, ("Found stale duplicate oplock\n"));
1267                                 continue;
1268                         }
1269                         /* Exclusive or batch - can only be one. */
1270                         if (*pp_ex_or_batch || *got_level2 || *got_no_oplock) {
1271                                 smb_panic("Bad exclusive or batch oplock entry.");
1272                         }
1273                         *pp_ex_or_batch = &lck->data->share_modes[i];
1274                 }
1275
1276                 if (LEVEL_II_OPLOCK_TYPE(lck->data->share_modes[i].op_type)) {
1277                         if (*pp_batch || *pp_ex_or_batch) {
1278                                 if (share_mode_stale_pid(lck->data, i)) {
1279                                         DEBUG(10, ("Found stale LevelII "
1280                                                    "oplock\n"));
1281                                         continue;
1282                                 }
1283                                 smb_panic("Bad levelII oplock entry.");
1284                         }
1285                         *got_level2 = true;
1286                 }
1287
1288                 if (lck->data->share_modes[i].op_type == NO_OPLOCK) {
1289                         if (*pp_batch || *pp_ex_or_batch) {
1290                                 if (share_mode_stale_pid(lck->data, i)) {
1291                                         DEBUG(10, ("Found stale NO_OPLOCK "
1292                                                    "entry\n"));
1293                                         continue;
1294                                 }
1295                                 smb_panic("Bad no oplock entry.");
1296                         }
1297                         *got_no_oplock = true;
1298                 }
1299         }
1300 }
1301
1302 static bool delay_for_batch_oplocks(files_struct *fsp,
1303                                         uint64_t mid,
1304                                         int oplock_request,
1305                                         struct share_mode_entry *batch_entry)
1306 {
1307         if ((oplock_request & INTERNAL_OPEN_ONLY) || is_stat_open(fsp->access_mask)) {
1308                 return false;
1309         }
1310         if (batch_entry == NULL) {
1311                 return false;
1312         }
1313
1314         if (server_id_is_disconnected(&batch_entry->pid)) {
1315                 /*
1316                  * TODO: clean up.
1317                  * This could be achieved by sending a break message
1318                  * to ourselves. Special considerations for files
1319                  * with delete_on_close flag set!
1320                  *
1321                  * For now we keep it simple and do not
1322                  * allow delete on close for durable handles.
1323                  */
1324                 return false;
1325         }
1326
1327         /* Found a batch oplock */
1328         send_break_message(fsp, batch_entry, mid, oplock_request);
1329         return true;
1330 }
1331
1332 static bool delay_for_exclusive_oplocks(files_struct *fsp,
1333                                         uint64_t mid,
1334                                         int oplock_request,
1335                                         struct share_mode_entry *ex_entry)
1336 {
1337         if ((oplock_request & INTERNAL_OPEN_ONLY) || is_stat_open(fsp->access_mask)) {
1338                 return false;
1339         }
1340         if (ex_entry == NULL) {
1341                 return false;
1342         }
1343
1344         if (server_id_is_disconnected(&ex_entry->pid)) {
1345                 /*
1346                  * since only durable handles can get disconnected,
1347                  * and we can only get durable handles with batch oplocks,
1348                  * this should actually never be reached...
1349                  */
1350                 return false;
1351         }
1352
1353         send_break_message(fsp, ex_entry, mid, oplock_request);
1354         return true;
1355 }
1356
1357 static bool file_has_brlocks(files_struct *fsp)
1358 {
1359         struct byte_range_lock *br_lck;
1360
1361         br_lck = brl_get_locks_readonly(fsp);
1362         if (!br_lck)
1363                 return false;
1364
1365         return br_lck->num_locks > 0 ? true : false;
1366 }
1367
1368 static void grant_fsp_oplock_type(files_struct *fsp,
1369                                 int oplock_request,
1370                                 bool got_level2_oplock,
1371                                 bool got_a_none_oplock)
1372 {
1373         bool allow_level2 = (global_client_caps & CAP_LEVEL_II_OPLOCKS) &&
1374                             lp_level2_oplocks(SNUM(fsp->conn));
1375
1376         /* Start by granting what the client asked for,
1377            but ensure no SAMBA_PRIVATE bits can be set. */
1378         fsp->oplock_type = (oplock_request & ~SAMBA_PRIVATE_OPLOCK_MASK);
1379
1380         if (oplock_request & INTERNAL_OPEN_ONLY) {
1381                 /* No oplocks on internal open. */
1382                 fsp->oplock_type = NO_OPLOCK;
1383                 DEBUG(10,("grant_fsp_oplock_type: oplock type 0x%x on file %s\n",
1384                         fsp->oplock_type, fsp_str_dbg(fsp)));
1385                 return;
1386         }
1387
1388         if (lp_locking(fsp->conn->params) && file_has_brlocks(fsp)) {
1389                 DEBUG(10,("grant_fsp_oplock_type: file %s has byte range locks\n",
1390                         fsp_str_dbg(fsp)));
1391                 fsp->oplock_type = NO_OPLOCK;
1392         }
1393
1394         if (is_stat_open(fsp->access_mask)) {
1395                 /* Leave the value already set. */
1396                 DEBUG(10,("grant_fsp_oplock_type: oplock type 0x%x on file %s\n",
1397                         fsp->oplock_type, fsp_str_dbg(fsp)));
1398                 return;
1399         }
1400
1401         /*
1402          * Match what was requested (fsp->oplock_type) with
1403          * what was found in the existing share modes.
1404          */
1405
1406         if (got_a_none_oplock) {
1407                 fsp->oplock_type = NO_OPLOCK;
1408         } else if (got_level2_oplock) {
1409                 if (fsp->oplock_type == NO_OPLOCK ||
1410                                 fsp->oplock_type == FAKE_LEVEL_II_OPLOCK) {
1411                         /* Store a level2 oplock, but don't tell the client */
1412                         fsp->oplock_type = FAKE_LEVEL_II_OPLOCK;
1413                 } else {
1414                         fsp->oplock_type = LEVEL_II_OPLOCK;
1415                 }
1416         } else {
1417                 /* All share_mode_entries are placeholders or deferred.
1418                  * Silently upgrade to fake levelII if the client didn't
1419                  * ask for an oplock. */
1420                 if (fsp->oplock_type == NO_OPLOCK) {
1421                         /* Store a level2 oplock, but don't tell the client */
1422                         fsp->oplock_type = FAKE_LEVEL_II_OPLOCK;
1423                 }
1424         }
1425
1426         /*
1427          * Don't grant level2 to clients that don't want them
1428          * or if we've turned them off.
1429          */
1430         if (fsp->oplock_type == LEVEL_II_OPLOCK && !allow_level2) {
1431                 fsp->oplock_type = FAKE_LEVEL_II_OPLOCK;
1432         }
1433
1434         DEBUG(10,("grant_fsp_oplock_type: oplock type 0x%x on file %s\n",
1435                   fsp->oplock_type, fsp_str_dbg(fsp)));
1436 }
1437
1438 static bool request_timed_out(struct timeval request_time,
1439                               struct timeval timeout)
1440 {
1441         struct timeval now, end_time;
1442         GetTimeOfDay(&now);
1443         end_time = timeval_sum(&request_time, &timeout);
1444         return (timeval_compare(&end_time, &now) < 0);
1445 }
1446
1447 struct defer_open_state {
1448         struct smbd_server_connection *sconn;
1449         uint64_t mid;
1450 };
1451
1452 static void defer_open_done(struct tevent_req *req);
1453
1454 /****************************************************************************
1455  Handle the 1 second delay in returning a SHARING_VIOLATION error.
1456 ****************************************************************************/
1457
1458 static void defer_open(struct share_mode_lock *lck,
1459                        struct timeval request_time,
1460                        struct timeval timeout,
1461                        struct smb_request *req,
1462                        struct deferred_open_record *state)
1463 {
1464         DEBUG(10,("defer_open_sharing_error: time [%u.%06u] adding deferred "
1465                   "open entry for mid %llu\n",
1466                   (unsigned int)request_time.tv_sec,
1467                   (unsigned int)request_time.tv_usec,
1468                   (unsigned long long)req->mid));
1469
1470         if (!push_deferred_open_message_smb(req, request_time, timeout,
1471                                        state->id, (char *)state, sizeof(*state))) {
1472                 TALLOC_FREE(lck);
1473                 exit_server("push_deferred_open_message_smb failed");
1474         }
1475         if (lck) {
1476                 struct defer_open_state *watch_state;
1477                 struct tevent_req *watch_req;
1478                 bool ret;
1479
1480                 watch_state = talloc(req->sconn, struct defer_open_state);
1481                 if (watch_state == NULL) {
1482                         exit_server("talloc failed");
1483                 }
1484                 watch_state->sconn = req->sconn;
1485                 watch_state->mid = req->mid;
1486
1487                 DEBUG(10, ("defering mid %llu\n",
1488                            (unsigned long long)req->mid));
1489
1490                 watch_req = dbwrap_record_watch_send(
1491                         watch_state, req->sconn->ev_ctx, lck->data->record,
1492                         req->sconn->msg_ctx);
1493                 if (watch_req == NULL) {
1494                         exit_server("Could not watch share mode record");
1495                 }
1496                 tevent_req_set_callback(watch_req, defer_open_done,
1497                                         watch_state);
1498
1499                 ret = tevent_req_set_endtime(
1500                         watch_req, req->sconn->ev_ctx,
1501                         timeval_sum(&request_time, &timeout));
1502                 SMB_ASSERT(ret);
1503         }
1504 }
1505
1506 static void defer_open_done(struct tevent_req *req)
1507 {
1508         struct defer_open_state *state = tevent_req_callback_data(
1509                 req, struct defer_open_state);
1510         NTSTATUS status;
1511         bool ret;
1512
1513         status = dbwrap_record_watch_recv(req, talloc_tos(), NULL);
1514         TALLOC_FREE(req);
1515         if (!NT_STATUS_IS_OK(status)) {
1516                 DEBUG(5, ("dbwrap_record_watch_recv returned %s\n",
1517                           nt_errstr(status)));
1518                 /*
1519                  * Even if it failed, retry anyway. TODO: We need a way to
1520                  * tell a re-scheduled open about that error.
1521                  */
1522         }
1523
1524         DEBUG(10, ("scheduling mid %llu\n", (unsigned long long)state->mid));
1525
1526         ret = schedule_deferred_open_message_smb(state->sconn, state->mid);
1527         SMB_ASSERT(ret);
1528         TALLOC_FREE(state);
1529 }
1530
1531
1532 /****************************************************************************
1533  On overwrite open ensure that the attributes match.
1534 ****************************************************************************/
1535
1536 static bool open_match_attributes(connection_struct *conn,
1537                                   uint32 old_dos_attr,
1538                                   uint32 new_dos_attr,
1539                                   mode_t existing_unx_mode,
1540                                   mode_t new_unx_mode,
1541                                   mode_t *returned_unx_mode)
1542 {
1543         uint32 noarch_old_dos_attr, noarch_new_dos_attr;
1544
1545         noarch_old_dos_attr = (old_dos_attr & ~FILE_ATTRIBUTE_ARCHIVE);
1546         noarch_new_dos_attr = (new_dos_attr & ~FILE_ATTRIBUTE_ARCHIVE);
1547
1548         if((noarch_old_dos_attr == 0 && noarch_new_dos_attr != 0) ||
1549            (noarch_old_dos_attr != 0 && ((noarch_old_dos_attr & noarch_new_dos_attr) == noarch_old_dos_attr))) {
1550                 *returned_unx_mode = new_unx_mode;
1551         } else {
1552                 *returned_unx_mode = (mode_t)0;
1553         }
1554
1555         DEBUG(10,("open_match_attributes: old_dos_attr = 0x%x, "
1556                   "existing_unx_mode = 0%o, new_dos_attr = 0x%x "
1557                   "returned_unx_mode = 0%o\n",
1558                   (unsigned int)old_dos_attr,
1559                   (unsigned int)existing_unx_mode,
1560                   (unsigned int)new_dos_attr,
1561                   (unsigned int)*returned_unx_mode ));
1562
1563         /* If we're mapping SYSTEM and HIDDEN ensure they match. */
1564         if (lp_map_system(SNUM(conn)) || lp_store_dos_attributes(SNUM(conn))) {
1565                 if ((old_dos_attr & FILE_ATTRIBUTE_SYSTEM) &&
1566                     !(new_dos_attr & FILE_ATTRIBUTE_SYSTEM)) {
1567                         return False;
1568                 }
1569         }
1570         if (lp_map_hidden(SNUM(conn)) || lp_store_dos_attributes(SNUM(conn))) {
1571                 if ((old_dos_attr & FILE_ATTRIBUTE_HIDDEN) &&
1572                     !(new_dos_attr & FILE_ATTRIBUTE_HIDDEN)) {
1573                         return False;
1574                 }
1575         }
1576         return True;
1577 }
1578
1579 /****************************************************************************
1580  Special FCB or DOS processing in the case of a sharing violation.
1581  Try and find a duplicated file handle.
1582 ****************************************************************************/
1583
1584 static NTSTATUS fcb_or_dos_open(struct smb_request *req,
1585                                 connection_struct *conn,
1586                                 files_struct *fsp_to_dup_into,
1587                                 const struct smb_filename *smb_fname,
1588                                 struct file_id id,
1589                                 uint16 file_pid,
1590                                 uint64_t vuid,
1591                                 uint32 access_mask,
1592                                 uint32 share_access,
1593                                 uint32 create_options)
1594 {
1595         files_struct *fsp;
1596
1597         DEBUG(5,("fcb_or_dos_open: attempting old open semantics for "
1598                  "file %s.\n", smb_fname_str_dbg(smb_fname)));
1599
1600         for(fsp = file_find_di_first(conn->sconn, id); fsp;
1601             fsp = file_find_di_next(fsp)) {
1602
1603                 DEBUG(10,("fcb_or_dos_open: checking file %s, fd = %d, "
1604                           "vuid = %llu, file_pid = %u, private_options = 0x%x "
1605                           "access_mask = 0x%x\n", fsp_str_dbg(fsp),
1606                           fsp->fh->fd, (unsigned long long)fsp->vuid,
1607                           (unsigned int)fsp->file_pid,
1608                           (unsigned int)fsp->fh->private_options,
1609                           (unsigned int)fsp->access_mask ));
1610
1611                 if (fsp != fsp_to_dup_into &&
1612                     fsp->fh->fd != -1 &&
1613                     fsp->vuid == vuid &&
1614                     fsp->file_pid == file_pid &&
1615                     (fsp->fh->private_options & (NTCREATEX_OPTIONS_PRIVATE_DENY_DOS |
1616                                                  NTCREATEX_OPTIONS_PRIVATE_DENY_FCB)) &&
1617                     (fsp->access_mask & FILE_WRITE_DATA) &&
1618                     strequal(fsp->fsp_name->base_name, smb_fname->base_name) &&
1619                     strequal(fsp->fsp_name->stream_name,
1620                              smb_fname->stream_name)) {
1621                         DEBUG(10,("fcb_or_dos_open: file match\n"));
1622                         break;
1623                 }
1624         }
1625
1626         if (!fsp) {
1627                 return NT_STATUS_NOT_FOUND;
1628         }
1629
1630         /* quite an insane set of semantics ... */
1631         if (is_executable(smb_fname->base_name) &&
1632             (fsp->fh->private_options & NTCREATEX_OPTIONS_PRIVATE_DENY_DOS)) {
1633                 DEBUG(10,("fcb_or_dos_open: file fail due to is_executable.\n"));
1634                 return NT_STATUS_INVALID_PARAMETER;
1635         }
1636
1637         /* We need to duplicate this fsp. */
1638         return dup_file_fsp(req, fsp, access_mask, share_access,
1639                             create_options, fsp_to_dup_into);
1640 }
1641
1642 static void schedule_defer_open(struct share_mode_lock *lck,
1643                                 struct timeval request_time,
1644                                 struct smb_request *req)
1645 {
1646         struct deferred_open_record state;
1647
1648         /* This is a relative time, added to the absolute
1649            request_time value to get the absolute timeout time.
1650            Note that if this is the second or greater time we enter
1651            this codepath for this particular request mid then
1652            request_time is left as the absolute time of the *first*
1653            time this request mid was processed. This is what allows
1654            the request to eventually time out. */
1655
1656         struct timeval timeout;
1657
1658         /* Normally the smbd we asked should respond within
1659          * OPLOCK_BREAK_TIMEOUT seconds regardless of whether
1660          * the client did, give twice the timeout as a safety
1661          * measure here in case the other smbd is stuck
1662          * somewhere else. */
1663
1664         timeout = timeval_set(OPLOCK_BREAK_TIMEOUT*2, 0);
1665
1666         /* Nothing actually uses state.delayed_for_oplocks
1667            but it's handy to differentiate in debug messages
1668            between a 30 second delay due to oplock break, and
1669            a 1 second delay for share mode conflicts. */
1670
1671         state.delayed_for_oplocks = True;
1672         state.async_open = false;
1673         state.id = lck->data->id;
1674
1675         if (!request_timed_out(request_time, timeout)) {
1676                 defer_open(lck, request_time, timeout, req, &state);
1677         }
1678 }
1679
1680 /****************************************************************************
1681  Reschedule an open call that went asynchronous.
1682 ****************************************************************************/
1683
1684 static void schedule_async_open(struct timeval request_time,
1685                                 struct smb_request *req)
1686 {
1687         struct deferred_open_record state;
1688         struct timeval timeout;
1689
1690         timeout = timeval_set(20, 0);
1691
1692         ZERO_STRUCT(state);
1693         state.delayed_for_oplocks = false;
1694         state.async_open = true;
1695
1696         if (!request_timed_out(request_time, timeout)) {
1697                 defer_open(NULL, request_time, timeout, req, &state);
1698         }
1699 }
1700
1701 /****************************************************************************
1702  Work out what access_mask to use from what the client sent us.
1703 ****************************************************************************/
1704
1705 static NTSTATUS smbd_calculate_maximum_allowed_access(
1706         connection_struct *conn,
1707         const struct smb_filename *smb_fname,
1708         bool use_privs,
1709         uint32_t *p_access_mask)
1710 {
1711         struct security_descriptor *sd;
1712         uint32_t access_granted;
1713         NTSTATUS status;
1714
1715         if (!use_privs && (get_current_uid(conn) == (uid_t)0)) {
1716                 *p_access_mask |= FILE_GENERIC_ALL;
1717                 return NT_STATUS_OK;
1718         }
1719
1720         status = SMB_VFS_GET_NT_ACL(conn, smb_fname->base_name,
1721                                     (SECINFO_OWNER |
1722                                      SECINFO_GROUP |
1723                                      SECINFO_DACL),
1724                                     talloc_tos(), &sd);
1725
1726         if (NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
1727                 /*
1728                  * File did not exist
1729                  */
1730                 *p_access_mask = FILE_GENERIC_ALL;
1731                 return NT_STATUS_OK;
1732         }
1733         if (!NT_STATUS_IS_OK(status)) {
1734                 DEBUG(10,("Could not get acl on file %s: %s\n",
1735                           smb_fname_str_dbg(smb_fname),
1736                           nt_errstr(status)));
1737                 return NT_STATUS_ACCESS_DENIED;
1738         }
1739
1740         /*
1741          * If we can access the path to this file, by
1742          * default we have FILE_READ_ATTRIBUTES from the
1743          * containing directory. See the section:
1744          * "Algorithm to Check Access to an Existing File"
1745          * in MS-FSA.pdf.
1746          *
1747          * se_file_access_check()
1748          * also takes care of owner WRITE_DAC and READ_CONTROL.
1749          */
1750         status = se_file_access_check(sd,
1751                                  get_current_nttok(conn),
1752                                  use_privs,
1753                                  (*p_access_mask & ~FILE_READ_ATTRIBUTES),
1754                                  &access_granted);
1755
1756         TALLOC_FREE(sd);
1757
1758         if (!NT_STATUS_IS_OK(status)) {
1759                 DEBUG(10, ("Access denied on file %s: "
1760                            "when calculating maximum access\n",
1761                            smb_fname_str_dbg(smb_fname)));
1762                 return NT_STATUS_ACCESS_DENIED;
1763         }
1764         *p_access_mask = (access_granted | FILE_READ_ATTRIBUTES);
1765
1766         if (!(access_granted & DELETE_ACCESS)) {
1767                 if (can_delete_file_in_directory(conn, smb_fname)) {
1768                         *p_access_mask |= DELETE_ACCESS;
1769                 }
1770         }
1771
1772         return NT_STATUS_OK;
1773 }
1774
1775 NTSTATUS smbd_calculate_access_mask(connection_struct *conn,
1776                                     const struct smb_filename *smb_fname,
1777                                     bool use_privs,
1778                                     uint32_t access_mask,
1779                                     uint32_t *access_mask_out)
1780 {
1781         NTSTATUS status;
1782         uint32_t orig_access_mask = access_mask;
1783         uint32_t rejected_share_access;
1784
1785         /*
1786          * Convert GENERIC bits to specific bits.
1787          */
1788
1789         se_map_generic(&access_mask, &file_generic_mapping);
1790
1791         /* Calculate MAXIMUM_ALLOWED_ACCESS if requested. */
1792         if (access_mask & MAXIMUM_ALLOWED_ACCESS) {
1793
1794                 status = smbd_calculate_maximum_allowed_access(
1795                         conn, smb_fname, use_privs, &access_mask);
1796
1797                 if (!NT_STATUS_IS_OK(status)) {
1798                         return status;
1799                 }
1800
1801                 access_mask &= conn->share_access;
1802         }
1803
1804         rejected_share_access = access_mask & ~(conn->share_access);
1805
1806         if (rejected_share_access) {
1807                 DEBUG(10, ("smbd_calculate_access_mask: Access denied on "
1808                         "file %s: rejected by share access mask[0x%08X] "
1809                         "orig[0x%08X] mapped[0x%08X] reject[0x%08X]\n",
1810                         smb_fname_str_dbg(smb_fname),
1811                         conn->share_access,
1812                         orig_access_mask, access_mask,
1813                         rejected_share_access));
1814                 return NT_STATUS_ACCESS_DENIED;
1815         }
1816
1817         *access_mask_out = access_mask;
1818         return NT_STATUS_OK;
1819 }
1820
1821 /****************************************************************************
1822  Remove the deferred open entry under lock.
1823 ****************************************************************************/
1824
1825 /****************************************************************************
1826  Return true if this is a state pointer to an asynchronous create.
1827 ****************************************************************************/
1828
1829 bool is_deferred_open_async(const void *ptr)
1830 {
1831         const struct deferred_open_record *state = (const struct deferred_open_record *)ptr;
1832
1833         return state->async_open;
1834 }
1835
1836 static bool clear_ads(uint32_t create_disposition)
1837 {
1838         bool ret = false;
1839
1840         switch (create_disposition) {
1841         case FILE_SUPERSEDE:
1842         case FILE_OVERWRITE_IF:
1843         case FILE_OVERWRITE:
1844                 ret = true;
1845                 break;
1846         default:
1847                 break;
1848         }
1849         return ret;
1850 }
1851
1852 static int disposition_to_open_flags(uint32_t create_disposition)
1853 {
1854         int ret = 0;
1855
1856         /*
1857          * Currently we're using FILE_SUPERSEDE as the same as
1858          * FILE_OVERWRITE_IF but they really are
1859          * different. FILE_SUPERSEDE deletes an existing file
1860          * (requiring delete access) then recreates it.
1861          */
1862
1863         switch (create_disposition) {
1864         case FILE_SUPERSEDE:
1865         case FILE_OVERWRITE_IF:
1866                 /*
1867                  * If file exists replace/overwrite. If file doesn't
1868                  * exist create.
1869                  */
1870                 ret = O_CREAT|O_TRUNC;
1871                 break;
1872
1873         case FILE_OPEN:
1874                 /*
1875                  * If file exists open. If file doesn't exist error.
1876                  */
1877                 ret = 0;
1878                 break;
1879
1880         case FILE_OVERWRITE:
1881                 /*
1882                  * If file exists overwrite. If file doesn't exist
1883                  * error.
1884                  */
1885                 ret = O_TRUNC;
1886                 break;
1887
1888         case FILE_CREATE:
1889                 /*
1890                  * If file exists error. If file doesn't exist create.
1891                  */
1892                 ret = O_CREAT|O_EXCL;
1893                 break;
1894
1895         case FILE_OPEN_IF:
1896                 /*
1897                  * If file exists open. If file doesn't exist create.
1898                  */
1899                 ret = O_CREAT;
1900                 break;
1901         }
1902         return ret;
1903 }
1904
1905 static int calculate_open_access_flags(uint32_t access_mask,
1906                                        int oplock_request,
1907                                        uint32_t private_flags)
1908 {
1909         bool need_write, need_read;
1910
1911         /*
1912          * Note that we ignore the append flag as append does not
1913          * mean the same thing under DOS and Unix.
1914          */
1915
1916         need_write =
1917                 ((access_mask & (FILE_WRITE_DATA | FILE_APPEND_DATA)) ||
1918                  (oplock_request & FORCE_OPLOCK_BREAK_TO_NONE));
1919
1920         if (!need_write) {
1921                 return O_RDONLY;
1922         }
1923
1924         /* DENY_DOS opens are always underlying read-write on the
1925            file handle, no matter what the requested access mask
1926            says. */
1927
1928         need_read =
1929                 ((private_flags & NTCREATEX_OPTIONS_PRIVATE_DENY_DOS) ||
1930                  access_mask & (FILE_READ_ATTRIBUTES|FILE_READ_DATA|
1931                                 FILE_READ_EA|FILE_EXECUTE));
1932
1933         if (!need_read) {
1934                 return O_WRONLY;
1935         }
1936         return O_RDWR;
1937 }
1938
1939 /****************************************************************************
1940  Open a file with a share mode. Passed in an already created files_struct *.
1941 ****************************************************************************/
1942
1943 static NTSTATUS open_file_ntcreate(connection_struct *conn,
1944                             struct smb_request *req,
1945                             uint32 access_mask,         /* access bits (FILE_READ_DATA etc.) */
1946                             uint32 share_access,        /* share constants (FILE_SHARE_READ etc) */
1947                             uint32 create_disposition,  /* FILE_OPEN_IF etc. */
1948                             uint32 create_options,      /* options such as delete on close. */
1949                             uint32 new_dos_attributes,  /* attributes used for new file. */
1950                             int oplock_request,         /* internal Samba oplock codes. */
1951                                                         /* Information (FILE_EXISTS etc.) */
1952                             uint32_t private_flags,     /* Samba specific flags. */
1953                             int *pinfo,
1954                             files_struct *fsp)
1955 {
1956         struct smb_filename *smb_fname = fsp->fsp_name;
1957         int flags=0;
1958         int flags2=0;
1959         bool file_existed = VALID_STAT(smb_fname->st);
1960         bool def_acl = False;
1961         bool posix_open = False;
1962         bool new_file_created = False;
1963         bool first_open_attempt = true;
1964         NTSTATUS fsp_open = NT_STATUS_ACCESS_DENIED;
1965         mode_t new_unx_mode = (mode_t)0;
1966         mode_t unx_mode = (mode_t)0;
1967         int info;
1968         uint32 existing_dos_attributes = 0;
1969         struct timeval request_time = timeval_zero();
1970         struct share_mode_lock *lck = NULL;
1971         uint32 open_access_mask = access_mask;
1972         NTSTATUS status;
1973         char *parent_dir;
1974         SMB_STRUCT_STAT saved_stat = smb_fname->st;
1975         struct share_mode_entry *batch_entry = NULL;
1976         struct share_mode_entry *exclusive_entry = NULL;
1977         bool got_level2_oplock = false;
1978         bool got_a_none_oplock = false;
1979         struct timespec old_write_time;
1980         struct file_id id;
1981
1982         if (conn->printer) {
1983                 /*
1984                  * Printers are handled completely differently.
1985                  * Most of the passed parameters are ignored.
1986                  */
1987
1988                 if (pinfo) {
1989                         *pinfo = FILE_WAS_CREATED;
1990                 }
1991
1992                 DEBUG(10, ("open_file_ntcreate: printer open fname=%s\n",
1993                            smb_fname_str_dbg(smb_fname)));
1994
1995                 if (!req) {
1996                         DEBUG(0,("open_file_ntcreate: printer open without "
1997                                 "an SMB request!\n"));
1998                         return NT_STATUS_INTERNAL_ERROR;
1999                 }
2000
2001                 return print_spool_open(fsp, smb_fname->base_name,
2002                                         req->vuid);
2003         }
2004
2005         if (!parent_dirname(talloc_tos(), smb_fname->base_name, &parent_dir,
2006                             NULL)) {
2007                 return NT_STATUS_NO_MEMORY;
2008         }
2009
2010         if (new_dos_attributes & FILE_FLAG_POSIX_SEMANTICS) {
2011                 posix_open = True;
2012                 unx_mode = (mode_t)(new_dos_attributes & ~FILE_FLAG_POSIX_SEMANTICS);
2013                 new_dos_attributes = 0;
2014         } else {
2015                 /* Windows allows a new file to be created and
2016                    silently removes a FILE_ATTRIBUTE_DIRECTORY
2017                    sent by the client. Do the same. */
2018
2019                 new_dos_attributes &= ~FILE_ATTRIBUTE_DIRECTORY;
2020
2021                 /* We add FILE_ATTRIBUTE_ARCHIVE to this as this mode is only used if the file is
2022                  * created new. */
2023                 unx_mode = unix_mode(conn, new_dos_attributes | FILE_ATTRIBUTE_ARCHIVE,
2024                                      smb_fname, parent_dir);
2025         }
2026
2027         DEBUG(10, ("open_file_ntcreate: fname=%s, dos_attrs=0x%x "
2028                    "access_mask=0x%x share_access=0x%x "
2029                    "create_disposition = 0x%x create_options=0x%x "
2030                    "unix mode=0%o oplock_request=%d private_flags = 0x%x\n",
2031                    smb_fname_str_dbg(smb_fname), new_dos_attributes,
2032                    access_mask, share_access, create_disposition,
2033                    create_options, (unsigned int)unx_mode, oplock_request,
2034                    (unsigned int)private_flags));
2035
2036         if ((req == NULL) && ((oplock_request & INTERNAL_OPEN_ONLY) == 0)) {
2037                 DEBUG(0, ("No smb request but not an internal only open!\n"));
2038                 return NT_STATUS_INTERNAL_ERROR;
2039         }
2040
2041         /*
2042          * Only non-internal opens can be deferred at all
2043          */
2044
2045         if (req) {
2046                 void *ptr;
2047                 if (get_deferred_open_message_state(req,
2048                                 &request_time,
2049                                 &ptr)) {
2050                         /* Remember the absolute time of the original
2051                            request with this mid. We'll use it later to
2052                            see if this has timed out. */
2053
2054                         /* If it was an async create retry, the file
2055                            didn't exist. */
2056
2057                         if (is_deferred_open_async(ptr)) {
2058                                 SET_STAT_INVALID(smb_fname->st);
2059                                 file_existed = false;
2060                         }
2061
2062                         /* Ensure we don't reprocess this message. */
2063                         remove_deferred_open_message_smb(req->sconn, req->mid);
2064
2065                         first_open_attempt = false;
2066                 }
2067         }
2068
2069         if (!posix_open) {
2070                 new_dos_attributes &= SAMBA_ATTRIBUTES_MASK;
2071                 if (file_existed) {
2072                         existing_dos_attributes = dos_mode(conn, smb_fname);
2073                 }
2074         }
2075
2076         /* ignore any oplock requests if oplocks are disabled */
2077         if (!lp_oplocks(SNUM(conn)) ||
2078             IS_VETO_OPLOCK_PATH(conn, smb_fname->base_name)) {
2079                 /* Mask off everything except the private Samba bits. */
2080                 oplock_request &= SAMBA_PRIVATE_OPLOCK_MASK;
2081         }
2082
2083         /* this is for OS/2 long file names - say we don't support them */
2084         if (!lp_posix_pathnames() && strstr(smb_fname->base_name,".+,;=[].")) {
2085                 /* OS/2 Workplace shell fix may be main code stream in a later
2086                  * release. */
2087                 DEBUG(5,("open_file_ntcreate: OS/2 long filenames are not "
2088                          "supported.\n"));
2089                 if (use_nt_status()) {
2090                         return NT_STATUS_OBJECT_NAME_NOT_FOUND;
2091                 }
2092                 return NT_STATUS_DOS(ERRDOS, ERRcannotopen);
2093         }
2094
2095         switch( create_disposition ) {
2096                 case FILE_OPEN:
2097                         /* If file exists open. If file doesn't exist error. */
2098                         if (!file_existed) {
2099                                 DEBUG(5,("open_file_ntcreate: FILE_OPEN "
2100                                          "requested for file %s and file "
2101                                          "doesn't exist.\n",
2102                                          smb_fname_str_dbg(smb_fname)));
2103                                 errno = ENOENT;
2104                                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
2105                         }
2106                         break;
2107
2108                 case FILE_OVERWRITE:
2109                         /* If file exists overwrite. If file doesn't exist
2110                          * error. */
2111                         if (!file_existed) {
2112                                 DEBUG(5,("open_file_ntcreate: FILE_OVERWRITE "
2113                                          "requested for file %s and file "
2114                                          "doesn't exist.\n",
2115                                          smb_fname_str_dbg(smb_fname) ));
2116                                 errno = ENOENT;
2117                                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
2118                         }
2119                         break;
2120
2121                 case FILE_CREATE:
2122                         /* If file exists error. If file doesn't exist
2123                          * create. */
2124                         if (file_existed) {
2125                                 DEBUG(5,("open_file_ntcreate: FILE_CREATE "
2126                                          "requested for file %s and file "
2127                                          "already exists.\n",
2128                                          smb_fname_str_dbg(smb_fname)));
2129                                 if (S_ISDIR(smb_fname->st.st_ex_mode)) {
2130                                         errno = EISDIR;
2131                                 } else {
2132                                         errno = EEXIST;
2133                                 }
2134                                 return map_nt_error_from_unix(errno);
2135                         }
2136                         break;
2137
2138                 case FILE_SUPERSEDE:
2139                 case FILE_OVERWRITE_IF:
2140                 case FILE_OPEN_IF:
2141                         break;
2142                 default:
2143                         return NT_STATUS_INVALID_PARAMETER;
2144         }
2145
2146         flags2 = disposition_to_open_flags(create_disposition);
2147
2148         /* We only care about matching attributes on file exists and
2149          * overwrite. */
2150
2151         if (!posix_open && file_existed &&
2152             ((create_disposition == FILE_OVERWRITE) ||
2153              (create_disposition == FILE_OVERWRITE_IF))) {
2154                 if (!open_match_attributes(conn, existing_dos_attributes,
2155                                            new_dos_attributes,
2156                                            smb_fname->st.st_ex_mode,
2157                                            unx_mode, &new_unx_mode)) {
2158                         DEBUG(5,("open_file_ntcreate: attributes missmatch "
2159                                  "for file %s (%x %x) (0%o, 0%o)\n",
2160                                  smb_fname_str_dbg(smb_fname),
2161                                  existing_dos_attributes,
2162                                  new_dos_attributes,
2163                                  (unsigned int)smb_fname->st.st_ex_mode,
2164                                  (unsigned int)unx_mode ));
2165                         errno = EACCES;
2166                         return NT_STATUS_ACCESS_DENIED;
2167                 }
2168         }
2169
2170         status = smbd_calculate_access_mask(conn, smb_fname,
2171                                         false,
2172                                         access_mask,
2173                                         &access_mask);
2174         if (!NT_STATUS_IS_OK(status)) {
2175                 DEBUG(10, ("open_file_ntcreate: smbd_calculate_access_mask "
2176                         "on file %s returned %s\n",
2177                         smb_fname_str_dbg(smb_fname), nt_errstr(status)));
2178                 return status;
2179         }
2180
2181         open_access_mask = access_mask;
2182
2183         if ((flags2 & O_TRUNC) || (oplock_request & FORCE_OPLOCK_BREAK_TO_NONE)) {
2184                 open_access_mask |= FILE_WRITE_DATA; /* This will cause oplock breaks. */
2185         }
2186
2187         DEBUG(10, ("open_file_ntcreate: fname=%s, after mapping "
2188                    "access_mask=0x%x\n", smb_fname_str_dbg(smb_fname),
2189                     access_mask));
2190
2191         /*
2192          * Note that we ignore the append flag as append does not
2193          * mean the same thing under DOS and Unix.
2194          */
2195
2196         flags = calculate_open_access_flags(access_mask, oplock_request,
2197                                             private_flags);
2198
2199         /*
2200          * Currently we only look at FILE_WRITE_THROUGH for create options.
2201          */
2202
2203 #if defined(O_SYNC)
2204         if ((create_options & FILE_WRITE_THROUGH) && lp_strict_sync(SNUM(conn))) {
2205                 flags2 |= O_SYNC;
2206         }
2207 #endif /* O_SYNC */
2208
2209         if (posix_open && (access_mask & FILE_APPEND_DATA)) {
2210                 flags2 |= O_APPEND;
2211         }
2212
2213         if (!posix_open && !CAN_WRITE(conn)) {
2214                 /*
2215                  * We should really return a permission denied error if either
2216                  * O_CREAT or O_TRUNC are set, but for compatibility with
2217                  * older versions of Samba we just AND them out.
2218                  */
2219                 flags2 &= ~(O_CREAT|O_TRUNC);
2220         }
2221
2222         if (first_open_attempt && lp_kernel_oplocks(SNUM(conn))) {
2223                 /*
2224                  * With kernel oplocks the open breaking an oplock
2225                  * blocks until the oplock holder has given up the
2226                  * oplock or closed the file. We prevent this by first
2227                  * trying to open the file with O_NONBLOCK (see "man
2228                  * fcntl" on Linux). For the second try, triggered by
2229                  * an oplock break response, we do not need this
2230                  * anymore.
2231                  *
2232                  * This is true under the assumption that only Samba
2233                  * requests kernel oplocks. Once someone else like
2234                  * NFSv4 starts to use that API, we will have to
2235                  * modify this by communicating with the NFSv4 server.
2236                  */
2237                 flags2 |= O_NONBLOCK;
2238         }
2239
2240         /*
2241          * Ensure we can't write on a read-only share or file.
2242          */
2243
2244         if (flags != O_RDONLY && file_existed &&
2245             (!CAN_WRITE(conn) || IS_DOS_READONLY(existing_dos_attributes))) {
2246                 DEBUG(5,("open_file_ntcreate: write access requested for "
2247                          "file %s on read only %s\n",
2248                          smb_fname_str_dbg(smb_fname),
2249                          !CAN_WRITE(conn) ? "share" : "file" ));
2250                 errno = EACCES;
2251                 return NT_STATUS_ACCESS_DENIED;
2252         }
2253
2254         fsp->file_id = vfs_file_id_from_sbuf(conn, &smb_fname->st);
2255         fsp->share_access = share_access;
2256         fsp->fh->private_options = private_flags;
2257         fsp->access_mask = open_access_mask; /* We change this to the
2258                                               * requested access_mask after
2259                                               * the open is done. */
2260         fsp->posix_open = posix_open;
2261
2262         /* Ensure no SAMBA_PRIVATE bits can be set. */
2263         fsp->oplock_type = (oplock_request & ~SAMBA_PRIVATE_OPLOCK_MASK);
2264
2265         if (timeval_is_zero(&request_time)) {
2266                 request_time = fsp->open_time;
2267         }
2268
2269         /*
2270          * Ensure we pay attention to default ACLs on directories if required.
2271          */
2272
2273         if ((flags2 & O_CREAT) && lp_inherit_acls(SNUM(conn)) &&
2274             (def_acl = directory_has_default_acl(conn, parent_dir))) {
2275                 unx_mode = (0777 & lp_create_mask(SNUM(conn)));
2276         }
2277
2278         DEBUG(4,("calling open_file with flags=0x%X flags2=0x%X mode=0%o, "
2279                 "access_mask = 0x%x, open_access_mask = 0x%x\n",
2280                  (unsigned int)flags, (unsigned int)flags2,
2281                  (unsigned int)unx_mode, (unsigned int)access_mask,
2282                  (unsigned int)open_access_mask));
2283
2284         fsp_open = open_file(fsp, conn, req, parent_dir,
2285                              flags|flags2, unx_mode, access_mask,
2286                              open_access_mask, &new_file_created);
2287
2288         if (NT_STATUS_EQUAL(fsp_open, NT_STATUS_NETWORK_BUSY)) {
2289                 struct deferred_open_record state;
2290
2291                 /*
2292                  * EWOULDBLOCK/EAGAIN maps to NETWORK_BUSY.
2293                  */
2294                 if (file_existed && S_ISFIFO(fsp->fsp_name->st.st_ex_mode)) {
2295                         DEBUG(10, ("FIFO busy\n"));
2296                         return NT_STATUS_NETWORK_BUSY;
2297                 }
2298                 if (req == NULL) {
2299                         DEBUG(10, ("Internal open busy\n"));
2300                         return NT_STATUS_NETWORK_BUSY;
2301                 }
2302
2303                 /*
2304                  * From here on we assume this is an oplock break triggered
2305                  */
2306
2307                 lck = get_existing_share_mode_lock(talloc_tos(), fsp->file_id);
2308                 if (lck == NULL) {
2309                         state.delayed_for_oplocks = false;
2310                         state.async_open = false;
2311                         state.id = fsp->file_id;
2312                         defer_open(NULL, request_time, timeval_set(0, 0),
2313                                    req, &state);
2314                         DEBUG(10, ("No share mode lock found after "
2315                                    "EWOULDBLOCK, retrying sync\n"));
2316                         return NT_STATUS_SHARING_VIOLATION;
2317                 }
2318
2319                 find_oplock_types(fsp, 0, lck, &batch_entry, &exclusive_entry,
2320                                   &got_level2_oplock, &got_a_none_oplock);
2321
2322                 if (delay_for_batch_oplocks(fsp, req->mid, 0, batch_entry) ||
2323                     delay_for_exclusive_oplocks(fsp, req->mid, 0,
2324                                                 exclusive_entry)) {
2325                         schedule_defer_open(lck, request_time, req);
2326                         TALLOC_FREE(lck);
2327                         DEBUG(10, ("Sent oplock break request to kernel "
2328                                    "oplock holder\n"));
2329                         return NT_STATUS_SHARING_VIOLATION;
2330                 }
2331
2332                 /*
2333                  * No oplock from Samba around. Immediately retry with
2334                  * a blocking open.
2335                  */
2336                 state.delayed_for_oplocks = false;
2337                 state.async_open = false;
2338                 state.id = lck->data->id;
2339                 defer_open(lck, request_time, timeval_set(0, 0), req, &state);
2340                 TALLOC_FREE(lck);
2341                 DEBUG(10, ("No Samba oplock around after EWOULDBLOCK. "
2342                            "Retrying sync\n"));
2343                 return NT_STATUS_SHARING_VIOLATION;
2344         }
2345
2346         if (!NT_STATUS_IS_OK(fsp_open)) {
2347                 if (NT_STATUS_EQUAL(fsp_open, NT_STATUS_RETRY)) {
2348                         schedule_async_open(request_time, req);
2349                 }
2350                 TALLOC_FREE(lck);
2351                 return fsp_open;
2352         }
2353
2354         if (file_existed && !check_same_dev_ino(&saved_stat, &smb_fname->st)) {
2355                 /*
2356                  * The file did exist, but some other (local or NFS)
2357                  * process either renamed/unlinked and re-created the
2358                  * file with different dev/ino after we walked the path,
2359                  * but before we did the open. We could retry the
2360                  * open but it's a rare enough case it's easier to
2361                  * just fail the open to prevent creating any problems
2362                  * in the open file db having the wrong dev/ino key.
2363                  */
2364                 TALLOC_FREE(lck);
2365                 fd_close(fsp);
2366                 DEBUG(1,("open_file_ntcreate: file %s - dev/ino mismatch. "
2367                         "Old (dev=0x%llu, ino =0x%llu). "
2368                         "New (dev=0x%llu, ino=0x%llu). Failing open "
2369                         " with NT_STATUS_ACCESS_DENIED.\n",
2370                          smb_fname_str_dbg(smb_fname),
2371                          (unsigned long long)saved_stat.st_ex_dev,
2372                          (unsigned long long)saved_stat.st_ex_ino,
2373                          (unsigned long long)smb_fname->st.st_ex_dev,
2374                          (unsigned long long)smb_fname->st.st_ex_ino));
2375                 return NT_STATUS_ACCESS_DENIED;
2376         }
2377
2378         old_write_time = smb_fname->st.st_ex_mtime;
2379
2380         /*
2381          * Deal with the race condition where two smbd's detect the
2382          * file doesn't exist and do the create at the same time. One
2383          * of them will win and set a share mode, the other (ie. this
2384          * one) should check if the requested share mode for this
2385          * create is allowed.
2386          */
2387
2388         /*
2389          * Now the file exists and fsp is successfully opened,
2390          * fsp->dev and fsp->inode are valid and should replace the
2391          * dev=0,inode=0 from a non existent file. Spotted by
2392          * Nadav Danieli <nadavd@exanet.com>. JRA.
2393          */
2394
2395         id = fsp->file_id;
2396
2397         lck = get_share_mode_lock(talloc_tos(), id,
2398                                   conn->connectpath,
2399                                   smb_fname, &old_write_time);
2400
2401         if (lck == NULL) {
2402                 DEBUG(0, ("open_file_ntcreate: Could not get share "
2403                           "mode lock for %s\n",
2404                           smb_fname_str_dbg(smb_fname)));
2405                 fd_close(fsp);
2406                 return NT_STATUS_SHARING_VIOLATION;
2407         }
2408
2409         /* Get the types we need to examine. */
2410         find_oplock_types(fsp,
2411                           oplock_request,
2412                           lck,
2413                           &batch_entry,
2414                           &exclusive_entry,
2415                           &got_level2_oplock,
2416                           &got_a_none_oplock);
2417
2418         /* First pass - send break only on batch oplocks. */
2419         if ((req != NULL) &&
2420             delay_for_batch_oplocks(fsp,
2421                                     req->mid,
2422                                     oplock_request,
2423                                     batch_entry)) {
2424                 schedule_defer_open(lck, request_time, req);
2425                 TALLOC_FREE(lck);
2426                 fd_close(fsp);
2427                 return NT_STATUS_SHARING_VIOLATION;
2428         }
2429
2430         status = open_mode_check(conn, lck, fsp->name_hash,
2431                                  access_mask, share_access,
2432                                  create_options, &file_existed);
2433
2434         if (NT_STATUS_IS_OK(status)) {
2435                 /* We might be going to allow this open. Check oplock
2436                  * status again. */
2437                 /* Second pass - send break for both batch or
2438                  * exclusive oplocks. */
2439                 if ((req != NULL) &&
2440                     delay_for_exclusive_oplocks(
2441                             fsp,
2442                             req->mid,
2443                             oplock_request,
2444                             exclusive_entry)) {
2445                         schedule_defer_open(lck, request_time, req);
2446                         TALLOC_FREE(lck);
2447                         fd_close(fsp);
2448                         return NT_STATUS_SHARING_VIOLATION;
2449                 }
2450         }
2451
2452         if (NT_STATUS_EQUAL(status, NT_STATUS_DELETE_PENDING)) {
2453                 /* DELETE_PENDING is not deferred for a second */
2454                 TALLOC_FREE(lck);
2455                 fd_close(fsp);
2456                 return status;
2457         }
2458
2459         if (!NT_STATUS_IS_OK(status)) {
2460                 uint32 can_access_mask;
2461                 bool can_access = True;
2462
2463                 SMB_ASSERT(NT_STATUS_EQUAL(status, NT_STATUS_SHARING_VIOLATION));
2464
2465                 /* Check if this can be done with the deny_dos and fcb
2466                  * calls. */
2467                 if (private_flags &
2468                     (NTCREATEX_OPTIONS_PRIVATE_DENY_DOS|
2469                      NTCREATEX_OPTIONS_PRIVATE_DENY_FCB)) {
2470                         if (req == NULL) {
2471                                 DEBUG(0, ("DOS open without an SMB "
2472                                           "request!\n"));
2473                                 TALLOC_FREE(lck);
2474                                 fd_close(fsp);
2475                                 return NT_STATUS_INTERNAL_ERROR;
2476                         }
2477
2478                         /* Use the client requested access mask here,
2479                          * not the one we open with. */
2480                         status = fcb_or_dos_open(req,
2481                                                  conn,
2482                                                  fsp,
2483                                                  smb_fname,
2484                                                  id,
2485                                                  req->smbpid,
2486                                                  req->vuid,
2487                                                  access_mask,
2488                                                  share_access,
2489                                                  create_options);
2490
2491                         if (NT_STATUS_IS_OK(status)) {
2492                                 TALLOC_FREE(lck);
2493                                 if (pinfo) {
2494                                         *pinfo = FILE_WAS_OPENED;
2495                                 }
2496                                 return NT_STATUS_OK;
2497                         }
2498                 }
2499
2500                 /*
2501                  * This next line is a subtlety we need for
2502                  * MS-Access. If a file open will fail due to share
2503                  * permissions and also for security (access) reasons,
2504                  * we need to return the access failed error, not the
2505                  * share error. We can't open the file due to kernel
2506                  * oplock deadlock (it's possible we failed above on
2507                  * the open_mode_check()) so use a userspace check.
2508                  */
2509
2510                 if (flags & O_RDWR) {
2511                         can_access_mask = FILE_READ_DATA|FILE_WRITE_DATA;
2512                 } else if (flags & O_WRONLY) {
2513                         can_access_mask = FILE_WRITE_DATA;
2514                 } else {
2515                         can_access_mask = FILE_READ_DATA;
2516                 }
2517
2518                 if (((can_access_mask & FILE_WRITE_DATA) &&
2519                      !CAN_WRITE(conn)) ||
2520                     !NT_STATUS_IS_OK(smbd_check_access_rights(conn,
2521                                                               smb_fname,
2522                                                               false,
2523                                                               can_access_mask))) {
2524                         can_access = False;
2525                 }
2526
2527                 /*
2528                  * If we're returning a share violation, ensure we
2529                  * cope with the braindead 1 second delay (SMB1 only).
2530                  */
2531
2532                 if (!(oplock_request & INTERNAL_OPEN_ONLY) &&
2533                     !conn->sconn->using_smb2 &&
2534                     lp_defer_sharing_violations()) {
2535                         struct timeval timeout;
2536                         struct deferred_open_record state;
2537                         int timeout_usecs;
2538
2539                         /* this is a hack to speed up torture tests
2540                            in 'make test' */
2541                         timeout_usecs = lp_parm_int(SNUM(conn),
2542                                                     "smbd","sharedelay",
2543                                                     SHARING_VIOLATION_USEC_WAIT);
2544
2545                         /* This is a relative time, added to the absolute
2546                            request_time value to get the absolute timeout time.
2547                            Note that if this is the second or greater time we enter
2548                            this codepath for this particular request mid then
2549                            request_time is left as the absolute time of the *first*
2550                            time this request mid was processed. This is what allows
2551                            the request to eventually time out. */
2552
2553                         timeout = timeval_set(0, timeout_usecs);
2554
2555                         /* Nothing actually uses state.delayed_for_oplocks
2556                            but it's handy to differentiate in debug messages
2557                            between a 30 second delay due to oplock break, and
2558                            a 1 second delay for share mode conflicts. */
2559
2560                         state.delayed_for_oplocks = False;
2561                         state.async_open = false;
2562                         state.id = id;
2563
2564                         if ((req != NULL)
2565                             && !request_timed_out(request_time,
2566                                                   timeout)) {
2567                                 defer_open(lck, request_time, timeout,
2568                                            req, &state);
2569                         }
2570                 }
2571
2572                 TALLOC_FREE(lck);
2573                 fd_close(fsp);
2574                 if (can_access) {
2575                         /*
2576                          * We have detected a sharing violation here
2577                          * so return the correct error code
2578                          */
2579                         status = NT_STATUS_SHARING_VIOLATION;
2580                 } else {
2581                         status = NT_STATUS_ACCESS_DENIED;
2582                 }
2583                 return status;
2584         }
2585
2586         grant_fsp_oplock_type(fsp,
2587                               oplock_request,
2588                               got_level2_oplock,
2589                               got_a_none_oplock);
2590
2591         /*
2592          * We have the share entry *locked*.....
2593          */
2594
2595         /* Delete streams if create_disposition requires it */
2596         if (!new_file_created && clear_ads(create_disposition) &&
2597             !is_ntfs_stream_smb_fname(smb_fname)) {
2598                 status = delete_all_streams(conn, smb_fname->base_name);
2599                 if (!NT_STATUS_IS_OK(status)) {
2600                         TALLOC_FREE(lck);
2601                         fd_close(fsp);
2602                         return status;
2603                 }
2604         }
2605
2606         /* note that we ignore failure for the following. It is
2607            basically a hack for NFS, and NFS will never set one of
2608            these only read them. Nobody but Samba can ever set a deny
2609            mode and we have already checked our more authoritative
2610            locking database for permission to set this deny mode. If
2611            the kernel refuses the operations then the kernel is wrong.
2612            note that GPFS supports it as well - jmcd */
2613
2614         if (fsp->fh->fd != -1 && lp_kernel_share_modes(SNUM(conn))) {
2615                 int ret_flock;
2616                 ret_flock = SMB_VFS_KERNEL_FLOCK(fsp, share_access, access_mask);
2617                 if(ret_flock == -1 ){
2618
2619                         TALLOC_FREE(lck);
2620                         fd_close(fsp);
2621
2622                         return NT_STATUS_SHARING_VIOLATION;
2623                 }
2624         }
2625
2626         /*
2627          * At this point onwards, we can guarantee that the share entry
2628          * is locked, whether we created the file or not, and that the
2629          * deny mode is compatible with all current opens.
2630          */
2631
2632         /*
2633          * According to Samba4, SEC_FILE_READ_ATTRIBUTE is always granted,
2634          * but we don't have to store this - just ignore it on access check.
2635          */
2636         if (conn->sconn->using_smb2) {
2637                 /*
2638                  * SMB2 doesn't return it (according to Microsoft tests).
2639                  * Test Case: TestSuite_ScenarioNo009GrantedAccessTestS0
2640                  * File created with access = 0x7 (Read, Write, Delete)
2641                  * Query Info on file returns 0x87 (Read, Write, Delete, Read Attributes)
2642                  */
2643                 fsp->access_mask = access_mask;
2644         } else {
2645                 /* But SMB1 does. */
2646                 fsp->access_mask = access_mask | FILE_READ_ATTRIBUTES;
2647         }
2648
2649         if (file_existed) {
2650                 /* stat opens on existing files don't get oplocks. */
2651                 if (is_stat_open(open_access_mask)) {
2652                         fsp->oplock_type = NO_OPLOCK;
2653                 }
2654         }
2655
2656         if (new_file_created) {
2657                 info = FILE_WAS_CREATED;
2658         } else {
2659                 if (flags2 & O_TRUNC) {
2660                         info = FILE_WAS_OVERWRITTEN;
2661                 } else {
2662                         info = FILE_WAS_OPENED;
2663                 }
2664         }
2665
2666         if (pinfo) {
2667                 *pinfo = info;
2668         }
2669
2670         /*
2671          * Setup the oplock info in both the shared memory and
2672          * file structs.
2673          */
2674
2675         status = set_file_oplock(fsp, fsp->oplock_type);
2676         if (!NT_STATUS_IS_OK(status)) {
2677                 /*
2678                  * Could not get the kernel oplock or there are byte-range
2679                  * locks on the file.
2680                  */
2681                 fsp->oplock_type = NO_OPLOCK;
2682         }
2683
2684         set_share_mode(lck, fsp, get_current_uid(conn),
2685                         req ? req->mid : 0,
2686                        fsp->oplock_type);
2687
2688         /* Handle strange delete on close create semantics. */
2689         if (create_options & FILE_DELETE_ON_CLOSE) {
2690
2691                 status = can_set_delete_on_close(fsp, new_dos_attributes);
2692
2693                 if (!NT_STATUS_IS_OK(status)) {
2694                         /* Remember to delete the mode we just added. */
2695                         del_share_mode(lck, fsp);
2696                         TALLOC_FREE(lck);
2697                         fd_close(fsp);
2698                         return status;
2699                 }
2700                 /* Note that here we set the *inital* delete on close flag,
2701                    not the regular one. The magic gets handled in close. */
2702                 fsp->initial_delete_on_close = True;
2703         }
2704
2705         if (info != FILE_WAS_OPENED) {
2706                 /* Files should be initially set as archive */
2707                 if (lp_map_archive(SNUM(conn)) ||
2708                     lp_store_dos_attributes(SNUM(conn))) {
2709                         if (!posix_open) {
2710                                 if (file_set_dosmode(conn, smb_fname,
2711                                             new_dos_attributes | FILE_ATTRIBUTE_ARCHIVE,
2712                                             parent_dir, true) == 0) {
2713                                         unx_mode = smb_fname->st.st_ex_mode;
2714                                 }
2715                         }
2716                 }
2717         }
2718
2719         /* Determine sparse flag. */
2720         if (posix_open) {
2721                 /* POSIX opens are sparse by default. */
2722                 fsp->is_sparse = true;
2723         } else {
2724                 fsp->is_sparse = (file_existed &&
2725                         (existing_dos_attributes & FILE_ATTRIBUTE_SPARSE));
2726         }
2727
2728         /*
2729          * Take care of inherited ACLs on created files - if default ACL not
2730          * selected.
2731          */
2732
2733         if (!posix_open && new_file_created && !def_acl) {
2734
2735                 int saved_errno = errno; /* We might get ENOSYS in the next
2736                                           * call.. */
2737
2738                 if (SMB_VFS_FCHMOD_ACL(fsp, unx_mode) == -1 &&
2739                     errno == ENOSYS) {
2740                         errno = saved_errno; /* Ignore ENOSYS */
2741                 }
2742
2743         } else if (new_unx_mode) {
2744
2745                 int ret = -1;
2746
2747                 /* Attributes need changing. File already existed. */
2748
2749                 {
2750                         int saved_errno = errno; /* We might get ENOSYS in the
2751                                                   * next call.. */
2752                         ret = SMB_VFS_FCHMOD_ACL(fsp, new_unx_mode);
2753
2754                         if (ret == -1 && errno == ENOSYS) {
2755                                 errno = saved_errno; /* Ignore ENOSYS */
2756                         } else {
2757                                 DEBUG(5, ("open_file_ntcreate: reset "
2758                                           "attributes of file %s to 0%o\n",
2759                                           smb_fname_str_dbg(smb_fname),
2760                                           (unsigned int)new_unx_mode));
2761                                 ret = 0; /* Don't do the fchmod below. */
2762                         }
2763                 }
2764
2765                 if ((ret == -1) &&
2766                     (SMB_VFS_FCHMOD(fsp, new_unx_mode) == -1))
2767                         DEBUG(5, ("open_file_ntcreate: failed to reset "
2768                                   "attributes of file %s to 0%o\n",
2769                                   smb_fname_str_dbg(smb_fname),
2770                                   (unsigned int)new_unx_mode));
2771         }
2772
2773         TALLOC_FREE(lck);
2774
2775         return NT_STATUS_OK;
2776 }
2777
2778
2779 /****************************************************************************
2780  Open a file for for write to ensure that we can fchmod it.
2781 ****************************************************************************/
2782
2783 NTSTATUS open_file_fchmod(connection_struct *conn,
2784                           struct smb_filename *smb_fname,
2785                           files_struct **result)
2786 {
2787         if (!VALID_STAT(smb_fname->st)) {
2788                 return NT_STATUS_INVALID_PARAMETER;
2789         }
2790
2791         return SMB_VFS_CREATE_FILE(
2792                 conn,                                   /* conn */
2793                 NULL,                                   /* req */
2794                 0,                                      /* root_dir_fid */
2795                 smb_fname,                              /* fname */
2796                 FILE_WRITE_DATA,                        /* access_mask */
2797                 (FILE_SHARE_READ | FILE_SHARE_WRITE |   /* share_access */
2798                     FILE_SHARE_DELETE),
2799                 FILE_OPEN,                              /* create_disposition*/
2800                 0,                                      /* create_options */
2801                 0,                                      /* file_attributes */
2802                 INTERNAL_OPEN_ONLY,                     /* oplock_request */
2803                 0,                                      /* allocation_size */
2804                 0,                                      /* private_flags */
2805                 NULL,                                   /* sd */
2806                 NULL,                                   /* ea_list */
2807                 result,                                 /* result */
2808                 NULL);                                  /* pinfo */
2809 }
2810
2811 static NTSTATUS mkdir_internal(connection_struct *conn,
2812                                struct smb_filename *smb_dname,
2813                                uint32 file_attributes)
2814 {
2815         mode_t mode;
2816         char *parent_dir = NULL;
2817         NTSTATUS status;
2818         bool posix_open = false;
2819         bool need_re_stat = false;
2820         uint32_t access_mask = SEC_DIR_ADD_SUBDIR;
2821
2822         if (!CAN_WRITE(conn) || (access_mask & ~(conn->share_access))) {
2823                 DEBUG(5,("mkdir_internal: failing share access "
2824                          "%s\n", lp_servicename(talloc_tos(), SNUM(conn))));
2825                 return NT_STATUS_ACCESS_DENIED;
2826         }
2827
2828         if (!parent_dirname(talloc_tos(), smb_dname->base_name, &parent_dir,
2829                             NULL)) {
2830                 return NT_STATUS_NO_MEMORY;
2831         }
2832
2833         if (file_attributes & FILE_FLAG_POSIX_SEMANTICS) {
2834                 posix_open = true;
2835                 mode = (mode_t)(file_attributes & ~FILE_FLAG_POSIX_SEMANTICS);
2836         } else {
2837                 mode = unix_mode(conn, FILE_ATTRIBUTE_DIRECTORY, smb_dname, parent_dir);
2838         }
2839
2840         status = check_parent_access(conn,
2841                                         smb_dname,
2842                                         access_mask);
2843         if(!NT_STATUS_IS_OK(status)) {
2844                 DEBUG(5,("mkdir_internal: check_parent_access "
2845                         "on directory %s for path %s returned %s\n",
2846                         parent_dir,
2847                         smb_dname->base_name,
2848                         nt_errstr(status) ));
2849                 return status;
2850         }
2851
2852         if (SMB_VFS_MKDIR(conn, smb_dname->base_name, mode) != 0) {
2853                 return map_nt_error_from_unix(errno);
2854         }
2855
2856         /* Ensure we're checking for a symlink here.... */
2857         /* We don't want to get caught by a symlink racer. */
2858
2859         if (SMB_VFS_LSTAT(conn, smb_dname) == -1) {
2860                 DEBUG(2, ("Could not stat directory '%s' just created: %s\n",
2861                           smb_fname_str_dbg(smb_dname), strerror(errno)));
2862                 return map_nt_error_from_unix(errno);
2863         }
2864
2865         if (!S_ISDIR(smb_dname->st.st_ex_mode)) {
2866                 DEBUG(0, ("Directory '%s' just created is not a directory !\n",
2867                           smb_fname_str_dbg(smb_dname)));
2868                 return NT_STATUS_NOT_A_DIRECTORY;
2869         }
2870
2871         if (lp_store_dos_attributes(SNUM(conn))) {
2872                 if (!posix_open) {
2873                         file_set_dosmode(conn, smb_dname,
2874                                          file_attributes | FILE_ATTRIBUTE_DIRECTORY,
2875                                          parent_dir, true);
2876                 }
2877         }
2878
2879         if (lp_inherit_perms(SNUM(conn))) {
2880                 inherit_access_posix_acl(conn, parent_dir,
2881                                          smb_dname->base_name, mode);
2882                 need_re_stat = true;
2883         }
2884
2885         if (!posix_open) {
2886                 /*
2887                  * Check if high bits should have been set,
2888                  * then (if bits are missing): add them.
2889                  * Consider bits automagically set by UNIX, i.e. SGID bit from parent
2890                  * dir.
2891                  */
2892                 if ((mode & ~(S_IRWXU|S_IRWXG|S_IRWXO)) &&
2893                     (mode & ~smb_dname->st.st_ex_mode)) {
2894                         SMB_VFS_CHMOD(conn, smb_dname->base_name,
2895                                       (smb_dname->st.st_ex_mode |
2896                                           (mode & ~smb_dname->st.st_ex_mode)));
2897                         need_re_stat = true;
2898                 }
2899         }
2900
2901         /* Change the owner if required. */
2902         if (lp_inherit_owner(SNUM(conn))) {
2903                 change_dir_owner_to_parent(conn, parent_dir,
2904                                            smb_dname->base_name,
2905                                            &smb_dname->st);
2906                 need_re_stat = true;
2907         }
2908
2909         if (need_re_stat) {
2910                 if (SMB_VFS_LSTAT(conn, smb_dname) == -1) {
2911                         DEBUG(2, ("Could not stat directory '%s' just created: %s\n",
2912                           smb_fname_str_dbg(smb_dname), strerror(errno)));
2913                         return map_nt_error_from_unix(errno);
2914                 }
2915         }
2916
2917         notify_fname(conn, NOTIFY_ACTION_ADDED, FILE_NOTIFY_CHANGE_DIR_NAME,
2918                      smb_dname->base_name);
2919
2920         return NT_STATUS_OK;
2921 }
2922
2923 /****************************************************************************
2924  Open a directory from an NT SMB call.
2925 ****************************************************************************/
2926
2927 static NTSTATUS open_directory(connection_struct *conn,
2928                                struct smb_request *req,
2929                                struct smb_filename *smb_dname,
2930                                uint32 access_mask,
2931                                uint32 share_access,
2932                                uint32 create_disposition,
2933                                uint32 create_options,
2934                                uint32 file_attributes,
2935                                int *pinfo,
2936                                files_struct **result)
2937 {
2938         files_struct *fsp = NULL;
2939         bool dir_existed = VALID_STAT(smb_dname->st) ? True : False;
2940         struct share_mode_lock *lck = NULL;
2941         NTSTATUS status;
2942         struct timespec mtimespec;
2943         int info = 0;
2944
2945         if (is_ntfs_stream_smb_fname(smb_dname)) {
2946                 DEBUG(2, ("open_directory: %s is a stream name!\n",
2947                           smb_fname_str_dbg(smb_dname)));
2948                 return NT_STATUS_NOT_A_DIRECTORY;
2949         }
2950
2951         if (!(file_attributes & FILE_FLAG_POSIX_SEMANTICS)) {
2952                 /* Ensure we have a directory attribute. */
2953                 file_attributes |= FILE_ATTRIBUTE_DIRECTORY;
2954         }
2955
2956         DEBUG(5,("open_directory: opening directory %s, access_mask = 0x%x, "
2957                  "share_access = 0x%x create_options = 0x%x, "
2958                  "create_disposition = 0x%x, file_attributes = 0x%x\n",
2959                  smb_fname_str_dbg(smb_dname),
2960                  (unsigned int)access_mask,
2961                  (unsigned int)share_access,
2962                  (unsigned int)create_options,
2963                  (unsigned int)create_disposition,
2964                  (unsigned int)file_attributes));
2965
2966         status = smbd_calculate_access_mask(conn, smb_dname, false,
2967                                             access_mask, &access_mask);
2968         if (!NT_STATUS_IS_OK(status)) {
2969                 DEBUG(10, ("open_directory: smbd_calculate_access_mask "
2970                         "on file %s returned %s\n",
2971                         smb_fname_str_dbg(smb_dname),
2972                         nt_errstr(status)));
2973                 return status;
2974         }
2975
2976         if ((access_mask & SEC_FLAG_SYSTEM_SECURITY) &&
2977                         !security_token_has_privilege(get_current_nttok(conn),
2978                                         SEC_PRIV_SECURITY)) {
2979                 DEBUG(10, ("open_directory: open on %s "
2980                         "failed - SEC_FLAG_SYSTEM_SECURITY denied.\n",
2981                         smb_fname_str_dbg(smb_dname)));
2982                 return NT_STATUS_PRIVILEGE_NOT_HELD;
2983         }
2984
2985         switch( create_disposition ) {
2986                 case FILE_OPEN:
2987
2988                         if (!dir_existed) {
2989                                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
2990                         }
2991
2992                         info = FILE_WAS_OPENED;
2993                         break;
2994
2995                 case FILE_CREATE:
2996
2997                         /* If directory exists error. If directory doesn't
2998                          * exist create. */
2999
3000                         if (dir_existed) {
3001                                 status = NT_STATUS_OBJECT_NAME_COLLISION;
3002                                 DEBUG(2, ("open_directory: unable to create "
3003                                           "%s. Error was %s\n",
3004                                           smb_fname_str_dbg(smb_dname),
3005                                           nt_errstr(status)));
3006                                 return status;
3007                         }
3008
3009                         status = mkdir_internal(conn, smb_dname,
3010                                                 file_attributes);
3011
3012                         if (!NT_STATUS_IS_OK(status)) {
3013                                 DEBUG(2, ("open_directory: unable to create "
3014                                           "%s. Error was %s\n",
3015                                           smb_fname_str_dbg(smb_dname),
3016                                           nt_errstr(status)));
3017                                 return status;
3018                         }
3019
3020                         info = FILE_WAS_CREATED;
3021                         break;
3022
3023                 case FILE_OPEN_IF:
3024                         /*
3025                          * If directory exists open. If directory doesn't
3026                          * exist create.
3027                          */
3028
3029                         if (dir_existed) {
3030                                 status = NT_STATUS_OK;
3031                                 info = FILE_WAS_OPENED;
3032                         } else {
3033                                 status = mkdir_internal(conn, smb_dname,
3034                                                 file_attributes);
3035
3036                                 if (NT_STATUS_IS_OK(status)) {
3037                                         info = FILE_WAS_CREATED;
3038                                 } else {
3039                                         /* Cope with create race. */
3040                                         if (!NT_STATUS_EQUAL(status,
3041                                                         NT_STATUS_OBJECT_NAME_COLLISION)) {
3042                                                 DEBUG(2, ("open_directory: unable to create "
3043                                                         "%s. Error was %s\n",
3044                                                         smb_fname_str_dbg(smb_dname),
3045                                                         nt_errstr(status)));
3046                                                 return status;
3047                                         }
3048                                         info = FILE_WAS_OPENED;
3049                                 }
3050                         }
3051
3052                         break;
3053
3054                 case FILE_SUPERSEDE:
3055                 case FILE_OVERWRITE:
3056                 case FILE_OVERWRITE_IF:
3057                 default:
3058                         DEBUG(5,("open_directory: invalid create_disposition "
3059                                  "0x%x for directory %s\n",
3060                                  (unsigned int)create_disposition,
3061                                  smb_fname_str_dbg(smb_dname)));
3062                         return NT_STATUS_INVALID_PARAMETER;
3063         }
3064
3065         if(!S_ISDIR(smb_dname->st.st_ex_mode)) {
3066                 DEBUG(5,("open_directory: %s is not a directory !\n",
3067                          smb_fname_str_dbg(smb_dname)));
3068                 return NT_STATUS_NOT_A_DIRECTORY;
3069         }
3070
3071         if (info == FILE_WAS_OPENED) {
3072                 status = smbd_check_access_rights(conn,
3073                                                 smb_dname,
3074                                                 false,
3075                                                 access_mask);
3076                 if (!NT_STATUS_IS_OK(status)) {
3077                         DEBUG(10, ("open_directory: smbd_check_access_rights on "
3078                                 "file %s failed with %s\n",
3079                                 smb_fname_str_dbg(smb_dname),
3080                                 nt_errstr(status)));
3081                         return status;
3082                 }
3083         }
3084
3085         status = file_new(req, conn, &fsp);
3086         if(!NT_STATUS_IS_OK(status)) {
3087                 return status;
3088         }
3089
3090         /*
3091          * Setup the files_struct for it.
3092          */
3093
3094         fsp->file_id = vfs_file_id_from_sbuf(conn, &smb_dname->st);
3095         fsp->vuid = req ? req->vuid : UID_FIELD_INVALID;
3096         fsp->file_pid = req ? req->smbpid : 0;
3097         fsp->can_lock = False;
3098         fsp->can_read = False;
3099         fsp->can_write = False;
3100
3101         fsp->share_access = share_access;
3102         fsp->fh->private_options = 0;
3103         /*
3104          * According to Samba4, SEC_FILE_READ_ATTRIBUTE is always granted,
3105          */
3106         fsp->access_mask = access_mask | FILE_READ_ATTRIBUTES;
3107         fsp->print_file = NULL;
3108         fsp->modified = False;
3109         fsp->oplock_type = NO_OPLOCK;
3110         fsp->sent_oplock_break = NO_BREAK_SENT;
3111         fsp->is_directory = True;
3112         fsp->posix_open = (file_attributes & FILE_FLAG_POSIX_SEMANTICS) ? True : False;
3113         status = fsp_set_smb_fname(fsp, smb_dname);
3114         if (!NT_STATUS_IS_OK(status)) {
3115                 file_free(req, fsp);
3116                 return status;
3117         }
3118
3119         mtimespec = smb_dname->st.st_ex_mtime;
3120
3121 #ifdef O_DIRECTORY
3122         status = fd_open(conn, fsp, O_RDONLY|O_DIRECTORY, 0);
3123 #else
3124         /* POSIX allows us to open a directory with O_RDONLY. */
3125         status = fd_open(conn, fsp, O_RDONLY, 0);
3126 #endif
3127         if (!NT_STATUS_IS_OK(status)) {
3128                 DEBUG(5, ("open_directory: Could not open fd for "
3129                         "%s (%s)\n",
3130                         smb_fname_str_dbg(smb_dname),
3131                         nt_errstr(status)));
3132                 file_free(req, fsp);
3133                 return status;
3134         }
3135
3136         status = vfs_stat_fsp(fsp);
3137         if (!NT_STATUS_IS_OK(status)) {
3138                 fd_close(fsp);
3139                 file_free(req, fsp);
3140                 return status;
3141         }
3142
3143         /* Ensure there was no race condition. */
3144         if (!check_same_stat(&smb_dname->st, &fsp->fsp_name->st)) {
3145                 DEBUG(5,("open_directory: stat struct differs for "
3146                         "directory %s.\n",
3147                         smb_fname_str_dbg(smb_dname)));
3148                 fd_close(fsp);
3149                 file_free(req, fsp);
3150                 return NT_STATUS_ACCESS_DENIED;
3151         }
3152
3153         lck = get_share_mode_lock(talloc_tos(), fsp->file_id,
3154                                   conn->connectpath, smb_dname,
3155                                   &mtimespec);
3156
3157         if (lck == NULL) {
3158                 DEBUG(0, ("open_directory: Could not get share mode lock for "
3159                           "%s\n", smb_fname_str_dbg(smb_dname)));
3160                 fd_close(fsp);
3161                 file_free(req, fsp);
3162                 return NT_STATUS_SHARING_VIOLATION;
3163         }
3164
3165         status = open_mode_check(conn, lck, fsp->name_hash,
3166                                 access_mask, share_access,
3167                                  create_options, &dir_existed);
3168
3169         if (!NT_STATUS_IS_OK(status)) {
3170                 TALLOC_FREE(lck);
3171                 fd_close(fsp);
3172                 file_free(req, fsp);
3173                 return status;
3174         }
3175
3176         set_share_mode(lck, fsp, get_current_uid(conn),
3177                         req ? req->mid : 0, NO_OPLOCK);
3178
3179         /* For directories the delete on close bit at open time seems
3180            always to be honored on close... See test 19 in Samba4 BASE-DELETE. */
3181         if (create_options & FILE_DELETE_ON_CLOSE) {
3182                 status = can_set_delete_on_close(fsp, 0);
3183                 if (!NT_STATUS_IS_OK(status) && !NT_STATUS_EQUAL(status, NT_STATUS_DIRECTORY_NOT_EMPTY)) {
3184                         TALLOC_FREE(lck);
3185                         fd_close(fsp);
3186                         file_free(req, fsp);
3187                         return status;
3188                 }
3189
3190                 if (NT_STATUS_IS_OK(status)) {
3191                         /* Note that here we set the *inital* delete on close flag,
3192                            not the regular one. The magic gets handled in close. */
3193                         fsp->initial_delete_on_close = True;
3194                 }
3195         }
3196
3197         TALLOC_FREE(lck);
3198
3199         if (pinfo) {
3200                 *pinfo = info;
3201         }
3202
3203         *result = fsp;
3204         return NT_STATUS_OK;
3205 }
3206
3207 NTSTATUS create_directory(connection_struct *conn, struct smb_request *req,
3208                           struct smb_filename *smb_dname)
3209 {
3210         NTSTATUS status;
3211         files_struct *fsp;
3212
3213         status = SMB_VFS_CREATE_FILE(
3214                 conn,                                   /* conn */
3215                 req,                                    /* req */
3216                 0,                                      /* root_dir_fid */
3217                 smb_dname,                              /* fname */
3218                 FILE_READ_ATTRIBUTES,                   /* access_mask */
3219                 FILE_SHARE_NONE,                        /* share_access */
3220                 FILE_CREATE,                            /* create_disposition*/
3221                 FILE_DIRECTORY_FILE,                    /* create_options */
3222                 FILE_ATTRIBUTE_DIRECTORY,               /* file_attributes */
3223                 0,                                      /* oplock_request */
3224                 0,                                      /* allocation_size */
3225                 0,                                      /* private_flags */
3226                 NULL,                                   /* sd */
3227                 NULL,                                   /* ea_list */
3228                 &fsp,                                   /* result */
3229                 NULL);                                  /* pinfo */
3230
3231         if (NT_STATUS_IS_OK(status)) {
3232                 close_file(req, fsp, NORMAL_CLOSE);
3233         }
3234
3235         return status;
3236 }
3237
3238 /****************************************************************************
3239  Receive notification that one of our open files has been renamed by another
3240  smbd process.
3241 ****************************************************************************/
3242
3243 void msg_file_was_renamed(struct messaging_context *msg,
3244                           void *private_data,
3245                           uint32_t msg_type,
3246                           struct server_id server_id,
3247                           DATA_BLOB *data)
3248 {
3249         files_struct *fsp;
3250         char *frm = (char *)data->data;
3251         struct file_id id;
3252         const char *sharepath;
3253         const char *base_name;
3254         const char *stream_name;
3255         struct smb_filename *smb_fname = NULL;
3256         size_t sp_len, bn_len;
3257         NTSTATUS status;
3258         struct smbd_server_connection *sconn =
3259                 talloc_get_type_abort(private_data,
3260                 struct smbd_server_connection);
3261
3262         if (data->data == NULL
3263             || data->length < MSG_FILE_RENAMED_MIN_SIZE + 2) {
3264                 DEBUG(0, ("msg_file_was_renamed: Got invalid msg len %d\n",
3265                           (int)data->length));
3266                 return;
3267         }
3268
3269         /* Unpack the message. */
3270         pull_file_id_24(frm, &id);
3271         sharepath = &frm[24];
3272         sp_len = strlen(sharepath);
3273         base_name = sharepath + sp_len + 1;
3274         bn_len = strlen(base_name);
3275         stream_name = sharepath + sp_len + 1 + bn_len + 1;
3276
3277         /* stream_name must always be NULL if there is no stream. */
3278         if (stream_name[0] == '\0') {
3279                 stream_name = NULL;
3280         }
3281
3282         smb_fname = synthetic_smb_fname(talloc_tos(), base_name,
3283                                         stream_name, NULL);
3284         if (smb_fname == NULL) {
3285                 return;
3286         }
3287
3288         DEBUG(10,("msg_file_was_renamed: Got rename message for sharepath %s, new name %s, "
3289                 "file_id %s\n",
3290                 sharepath, smb_fname_str_dbg(smb_fname),
3291                 file_id_string_tos(&id)));
3292
3293         for(fsp = file_find_di_first(sconn, id); fsp;
3294             fsp = file_find_di_next(fsp)) {
3295                 if (memcmp(fsp->conn->connectpath, sharepath, sp_len) == 0) {
3296
3297                         DEBUG(10,("msg_file_was_renamed: renaming file %s from %s -> %s\n",
3298                                 fsp_fnum_dbg(fsp), fsp_str_dbg(fsp),
3299                                 smb_fname_str_dbg(smb_fname)));
3300                         status = fsp_set_smb_fname(fsp, smb_fname);
3301                         if (!NT_STATUS_IS_OK(status)) {
3302                                 goto out;
3303                         }
3304                 } else {
3305                         /* TODO. JRA. */
3306                         /* Now we have the complete path we can work out if this is
3307                            actually within this share and adjust newname accordingly. */
3308                         DEBUG(10,("msg_file_was_renamed: share mismatch (sharepath %s "
3309                                 "not sharepath %s) "
3310                                 "%s from %s -> %s\n",
3311                                 fsp->conn->connectpath,
3312                                 sharepath,
3313                                 fsp_fnum_dbg(fsp),
3314                                 fsp_str_dbg(fsp),
3315                                 smb_fname_str_dbg(smb_fname)));
3316                 }
3317         }
3318  out:
3319         TALLOC_FREE(smb_fname);
3320         return;
3321 }
3322
3323 /*
3324  * If a main file is opened for delete, all streams need to be checked for
3325  * !FILE_SHARE_DELETE. Do this by opening with DELETE_ACCESS.
3326  * If that works, delete them all by setting the delete on close and close.
3327  */
3328
3329 NTSTATUS open_streams_for_delete(connection_struct *conn,
3330                                         const char *fname)
3331 {
3332         struct stream_struct *stream_info = NULL;
3333         files_struct **streams = NULL;
3334         int i;
3335         unsigned int num_streams = 0;
3336         TALLOC_CTX *frame = talloc_stackframe();
3337         NTSTATUS status;
3338
3339         status = vfs_streaminfo(conn, NULL, fname, talloc_tos(),
3340                                 &num_streams, &stream_info);
3341
3342         if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_IMPLEMENTED)
3343             || NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
3344                 DEBUG(10, ("no streams around\n"));
3345                 TALLOC_FREE(frame);
3346                 return NT_STATUS_OK;
3347         }
3348
3349         if (!NT_STATUS_IS_OK(status)) {
3350                 DEBUG(10, ("vfs_streaminfo failed: %s\n",
3351                            nt_errstr(status)));
3352                 goto fail;
3353         }
3354
3355         DEBUG(10, ("open_streams_for_delete found %d streams\n",
3356                    num_streams));
3357
3358         if (num_streams == 0) {
3359                 TALLOC_FREE(frame);
3360                 return NT_STATUS_OK;
3361         }
3362
3363         streams = talloc_array(talloc_tos(), files_struct *, num_streams);
3364         if (streams == NULL) {
3365                 DEBUG(0, ("talloc failed\n"));
3366                 status = NT_STATUS_NO_MEMORY;
3367                 goto fail;
3368         }
3369
3370         for (i=0; i<num_streams; i++) {
3371                 struct smb_filename *smb_fname;
3372
3373                 if (strequal(stream_info[i].name, "::$DATA")) {
3374                         streams[i] = NULL;
3375                         continue;
3376                 }
3377
3378                 smb_fname = synthetic_smb_fname(
3379                         talloc_tos(), fname, stream_info[i].name, NULL);
3380                 if (smb_fname == NULL) {
3381                         status = NT_STATUS_NO_MEMORY;
3382                         goto fail;
3383                 }
3384
3385                 if (SMB_VFS_STAT(conn, smb_fname) == -1) {
3386                         DEBUG(10, ("Unable to stat stream: %s\n",
3387                                    smb_fname_str_dbg(smb_fname)));
3388                 }
3389
3390                 status = SMB_VFS_CREATE_FILE(
3391                          conn,                  /* conn */
3392                          NULL,                  /* req */
3393                          0,                     /* root_dir_fid */
3394                          smb_fname,             /* fname */
3395                          DELETE_ACCESS,         /* access_mask */
3396                          (FILE_SHARE_READ |     /* share_access */
3397                              FILE_SHARE_WRITE | FILE_SHARE_DELETE),
3398                          FILE_OPEN,             /* create_disposition*/
3399                          0,                     /* create_options */
3400                          FILE_ATTRIBUTE_NORMAL, /* file_attributes */
3401                          0,                     /* oplock_request */
3402                          0,                     /* allocation_size */
3403                          NTCREATEX_OPTIONS_PRIVATE_STREAM_DELETE, /* private_flags */
3404                          NULL,                  /* sd */
3405                          NULL,                  /* ea_list */
3406                          &streams[i],           /* result */
3407                          NULL);                 /* pinfo */
3408
3409                 if (!NT_STATUS_IS_OK(status)) {
3410                         DEBUG(10, ("Could not open stream %s: %s\n",
3411                                    smb_fname_str_dbg(smb_fname),
3412                                    nt_errstr(status)));
3413
3414                         TALLOC_FREE(smb_fname);
3415                         break;
3416                 }
3417                 TALLOC_FREE(smb_fname);
3418         }
3419
3420         /*
3421          * don't touch the variable "status" beyond this point :-)
3422          */
3423
3424         for (i -= 1 ; i >= 0; i--) {
3425                 if (streams[i] == NULL) {
3426                         continue;
3427                 }
3428
3429                 DEBUG(10, ("Closing stream # %d, %s\n", i,
3430                            fsp_str_dbg(streams[i])));
3431                 close_file(NULL, streams[i], NORMAL_CLOSE);
3432         }
3433
3434  fail:
3435         TALLOC_FREE(frame);
3436         return status;
3437 }
3438
3439 /*********************************************************************
3440  Create a default ACL by inheriting from the parent. If no inheritance
3441  from the parent available, don't set anything. This will leave the actual
3442  permissions the new file or directory already got from the filesystem
3443  as the NT ACL when read.
3444 *********************************************************************/
3445
3446 static NTSTATUS inherit_new_acl(files_struct *fsp)
3447 {
3448         TALLOC_CTX *frame = talloc_stackframe();
3449         char *parent_name = NULL;
3450         struct security_descriptor *parent_desc = NULL;
3451         NTSTATUS status = NT_STATUS_OK;
3452         struct security_descriptor *psd = NULL;
3453         const struct dom_sid *owner_sid = NULL;
3454         const struct dom_sid *group_sid = NULL;
3455         uint32_t security_info_sent = (SECINFO_OWNER | SECINFO_GROUP | SECINFO_DACL);
3456         struct security_token *token = fsp->conn->session_info->security_token;
3457         bool inherit_owner = lp_inherit_owner(SNUM(fsp->conn));
3458         bool inheritable_components = false;
3459         bool try_builtin_administrators = false;
3460         const struct dom_sid *BA_U_sid = NULL;
3461         const struct dom_sid *BA_G_sid = NULL;
3462         bool try_system = false;
3463         const struct dom_sid *SY_U_sid = NULL;
3464         const struct dom_sid *SY_G_sid = NULL;
3465         size_t size = 0;
3466
3467         if (!parent_dirname(frame, fsp->fsp_name->base_name, &parent_name, NULL)) {
3468                 TALLOC_FREE(frame);
3469                 return NT_STATUS_NO_MEMORY;
3470         }
3471
3472         status = SMB_VFS_GET_NT_ACL(fsp->conn,
3473                                     parent_name,
3474                                     (SECINFO_OWNER | SECINFO_GROUP | SECINFO_DACL),
3475                                     frame,
3476                                     &parent_desc);
3477         if (!NT_STATUS_IS_OK(status)) {
3478                 TALLOC_FREE(frame);
3479                 return status;
3480         }
3481
3482         inheritable_components = sd_has_inheritable_components(parent_desc,
3483                                         fsp->is_directory);
3484
3485         if (!inheritable_components && !inherit_owner) {
3486                 TALLOC_FREE(frame);
3487                 /* Nothing to inherit and not setting owner. */
3488                 return NT_STATUS_OK;
3489         }
3490
3491         /* Create an inherited descriptor from the parent. */
3492
3493         if (DEBUGLEVEL >= 10) {
3494                 DEBUG(10,("inherit_new_acl: parent acl for %s is:\n",
3495                         fsp_str_dbg(fsp) ));
3496                 NDR_PRINT_DEBUG(security_descriptor, parent_desc);
3497         }
3498
3499         /* Inherit from parent descriptor if "inherit owner" set. */
3500         if (inherit_owner) {
3501                 owner_sid = parent_desc->owner_sid;
3502                 group_sid = parent_desc->group_sid;
3503         }
3504
3505         if (owner_sid == NULL) {
3506                 if (security_token_has_builtin_administrators(token)) {
3507                         try_builtin_administrators = true;
3508                 } else if (security_token_is_system(token)) {
3509                         try_builtin_administrators = true;
3510                         try_system = true;
3511                 }
3512         }
3513
3514         if (group_sid == NULL &&
3515             token->num_sids == PRIMARY_GROUP_SID_INDEX)
3516         {
3517                 if (security_token_is_system(token)) {
3518                         try_builtin_administrators = true;
3519                         try_system = true;
3520                 }
3521         }
3522
3523         if (try_builtin_administrators) {
3524                 struct unixid ids;
3525                 bool ok;
3526
3527                 ZERO_STRUCT(ids);
3528                 ok = sids_to_unixids(&global_sid_Builtin_Administrators, 1, &ids);
3529                 if (ok) {
3530                         switch (ids.type) {
3531                         case ID_TYPE_BOTH:
3532                                 BA_U_sid = &global_sid_Builtin_Administrators;
3533                                 BA_G_sid = &global_sid_Builtin_Administrators;
3534                                 break;
3535                         case ID_TYPE_UID:
3536                                 BA_U_sid = &global_sid_Builtin_Administrators;
3537                                 break;
3538                         case ID_TYPE_GID:
3539                                 BA_G_sid = &global_sid_Builtin_Administrators;
3540                                 break;
3541                         default:
3542                                 break;
3543                         }
3544                 }
3545         }
3546
3547         if (try_system) {
3548                 struct unixid ids;
3549                 bool ok;
3550
3551                 ZERO_STRUCT(ids);
3552                 ok = sids_to_unixids(&global_sid_System, 1, &ids);
3553                 if (ok) {
3554                         switch (ids.type) {
3555                         case ID_TYPE_BOTH:
3556                                 SY_U_sid = &global_sid_System;
3557                                 SY_G_sid = &global_sid_System;
3558                                 break;
3559                         case ID_TYPE_UID:
3560                                 SY_U_sid = &global_sid_System;
3561                                 break;
3562                         case ID_TYPE_GID:
3563                                 SY_G_sid = &global_sid_System;
3564                                 break;
3565                         default:
3566                                 break;
3567                         }
3568                 }
3569         }
3570
3571         if (owner_sid == NULL) {
3572                 owner_sid = BA_U_sid;
3573         }
3574
3575         if (owner_sid == NULL) {
3576                 owner_sid = SY_U_sid;
3577         }
3578
3579         if (group_sid == NULL) {
3580                 group_sid = SY_G_sid;
3581         }
3582
3583         if (try_system && group_sid == NULL) {
3584                 group_sid = BA_G_sid;
3585         }
3586
3587         if (owner_sid == NULL) {
3588                 owner_sid = &token->sids[PRIMARY_USER_SID_INDEX];
3589         }
3590         if (group_sid == NULL) {
3591                 if (token->num_sids == PRIMARY_GROUP_SID_INDEX) {
3592                         group_sid = &token->sids[PRIMARY_USER_SID_INDEX];
3593                 } else {
3594                         group_sid = &token->sids[PRIMARY_GROUP_SID_INDEX];
3595                 }
3596         }
3597
3598         status = se_create_child_secdesc(frame,
3599                         &psd,
3600                         &size,
3601                         parent_desc,
3602                         owner_sid,
3603                         group_sid,
3604                         fsp->is_directory);
3605         if (!NT_STATUS_IS_OK(status)) {
3606                 TALLOC_FREE(frame);
3607                 return status;
3608         }
3609
3610         /* If inheritable_components == false,
3611            se_create_child_secdesc()
3612            creates a security desriptor with a NULL dacl
3613            entry, but with SEC_DESC_DACL_PRESENT. We need
3614            to remove that flag. */
3615
3616         if (!inheritable_components) {
3617                 security_info_sent &= ~SECINFO_DACL;
3618                 psd->type &= ~SEC_DESC_DACL_PRESENT;
3619         }
3620
3621         if (DEBUGLEVEL >= 10) {
3622                 DEBUG(10,("inherit_new_acl: child acl for %s is:\n",
3623                         fsp_str_dbg(fsp) ));
3624                 NDR_PRINT_DEBUG(security_descriptor, psd);
3625         }
3626
3627         if (inherit_owner) {
3628                 /* We need to be root to force this. */
3629                 become_root();
3630         }
3631         status = SMB_VFS_FSET_NT_ACL(fsp,
3632                         security_info_sent,
3633                         psd);
3634         if (inherit_owner) {
3635                 unbecome_root();
3636         }
3637         TALLOC_FREE(frame);
3638         return status;
3639 }
3640
3641 /*
3642  * Wrapper around open_file_ntcreate and open_directory
3643  */
3644
3645 static NTSTATUS create_file_unixpath(connection_struct *conn,
3646                                      struct smb_request *req,
3647                                      struct smb_filename *smb_fname,
3648                                      uint32_t access_mask,
3649                                      uint32_t share_access,
3650                                      uint32_t create_disposition,
3651                                      uint32_t create_options,
3652                                      uint32_t file_attributes,
3653                                      uint32_t oplock_request,
3654                                      uint64_t allocation_size,
3655                                      uint32_t private_flags,
3656                                      struct security_descriptor *sd,
3657                                      struct ea_list *ea_list,
3658
3659                                      files_struct **result,
3660                                      int *pinfo)
3661 {
3662         int info = FILE_WAS_OPENED;
3663         files_struct *base_fsp = NULL;
3664         files_struct *fsp = NULL;
3665         NTSTATUS status;
3666
3667         DEBUG(10,("create_file_unixpath: access_mask = 0x%x "
3668                   "file_attributes = 0x%x, share_access = 0x%x, "
3669                   "create_disposition = 0x%x create_options = 0x%x "
3670                   "oplock_request = 0x%x private_flags = 0x%x "
3671                   "ea_list = 0x%p, sd = 0x%p, "
3672                   "fname = %s\n",
3673                   (unsigned int)access_mask,
3674                   (unsigned int)file_attributes,
3675                   (unsigned int)share_access,
3676                   (unsigned int)create_disposition,
3677                   (unsigned int)create_options,
3678                   (unsigned int)oplock_request,
3679                   (unsigned int)private_flags,
3680                   ea_list, sd, smb_fname_str_dbg(smb_fname)));
3681
3682         if (create_options & FILE_OPEN_BY_FILE_ID) {
3683                 status = NT_STATUS_NOT_SUPPORTED;
3684                 goto fail;
3685         }
3686
3687         if (create_options & NTCREATEX_OPTIONS_INVALID_PARAM_MASK) {
3688                 status = NT_STATUS_INVALID_PARAMETER;
3689                 goto fail;
3690         }
3691
3692         if (req == NULL) {
3693                 oplock_request |= INTERNAL_OPEN_ONLY;
3694         }
3695
3696         if ((conn->fs_capabilities & FILE_NAMED_STREAMS)
3697             && (access_mask & DELETE_ACCESS)
3698             && !is_ntfs_stream_smb_fname(smb_fname)) {
3699                 /*
3700                  * We can't open a file with DELETE access if any of the
3701                  * streams is open without FILE_SHARE_DELETE
3702                  */
3703                 status = open_streams_for_delete(conn, smb_fname->base_name);
3704
3705                 if (!NT_STATUS_IS_OK(status)) {
3706                         goto fail;
3707                 }
3708         }
3709
3710         if ((access_mask & SEC_FLAG_SYSTEM_SECURITY) &&
3711                         !security_token_has_privilege(get_current_nttok(conn),
3712                                         SEC_PRIV_SECURITY)) {
3713                 DEBUG(10, ("create_file_unixpath: open on %s "
3714                         "failed - SEC_FLAG_SYSTEM_SECURITY denied.\n",
3715                         smb_fname_str_dbg(smb_fname)));
3716                 status = NT_STATUS_PRIVILEGE_NOT_HELD;
3717                 goto fail;
3718         }
3719
3720         if ((conn->fs_capabilities & FILE_NAMED_STREAMS)
3721             && is_ntfs_stream_smb_fname(smb_fname)
3722             && (!(private_flags & NTCREATEX_OPTIONS_PRIVATE_STREAM_DELETE))) {
3723                 uint32 base_create_disposition;
3724                 struct smb_filename *smb_fname_base = NULL;
3725
3726                 if (create_options & FILE_DIRECTORY_FILE) {
3727                         status = NT_STATUS_NOT_A_DIRECTORY;
3728                         goto fail;
3729                 }
3730
3731                 switch (create_disposition) {
3732                 case FILE_OPEN:
3733                         base_create_disposition = FILE_OPEN;
3734                         break;
3735                 default:
3736                         base_create_disposition = FILE_OPEN_IF;
3737                         break;
3738                 }
3739
3740                 /* Create an smb_filename with stream_name == NULL. */
3741                 smb_fname_base = synthetic_smb_fname(talloc_tos(),
3742                                                      smb_fname->base_name,
3743                                                      NULL, NULL);
3744                 if (smb_fname_base == NULL) {
3745                         status = NT_STATUS_NO_MEMORY;
3746                         goto fail;
3747                 }
3748
3749                 if (SMB_VFS_STAT(conn, smb_fname_base) == -1) {
3750                         DEBUG(10, ("Unable to stat stream: %s\n",
3751                                    smb_fname_str_dbg(smb_fname_base)));
3752                 }
3753
3754                 /* Open the base file. */
3755                 status = create_file_unixpath(conn, NULL, smb_fname_base, 0,
3756                                               FILE_SHARE_READ
3757                                               | FILE_SHARE_WRITE
3758                                               | FILE_SHARE_DELETE,
3759                                               base_create_disposition,
3760                                               0, 0, 0, 0, 0, NULL, NULL,
3761                                               &base_fsp, NULL);
3762                 TALLOC_FREE(smb_fname_base);
3763
3764                 if (!NT_STATUS_IS_OK(status)) {
3765                         DEBUG(10, ("create_file_unixpath for base %s failed: "
3766                                    "%s\n", smb_fname->base_name,
3767                                    nt_errstr(status)));
3768                         goto fail;
3769                 }
3770                 /* we don't need to low level fd */
3771                 fd_close(base_fsp);
3772         }
3773
3774         /*
3775          * If it's a request for a directory open, deal with it separately.
3776          */
3777
3778         if (create_options & FILE_DIRECTORY_FILE) {
3779
3780                 if (create_options & FILE_NON_DIRECTORY_FILE) {
3781                         status = NT_STATUS_INVALID_PARAMETER;
3782                         goto fail;
3783                 }
3784
3785                 /* Can't open a temp directory. IFS kit test. */
3786                 if (!(file_attributes & FILE_FLAG_POSIX_SEMANTICS) &&
3787                      (file_attributes & FILE_ATTRIBUTE_TEMPORARY)) {
3788                         status = NT_STATUS_INVALID_PARAMETER;
3789                         goto fail;
3790                 }
3791
3792                 /*
3793                  * We will get a create directory here if the Win32
3794                  * app specified a security descriptor in the
3795                  * CreateDirectory() call.
3796                  */
3797
3798                 oplock_request = 0;
3799                 status = open_directory(
3800                         conn, req, smb_fname, access_mask, share_access,
3801                         create_disposition, create_options, file_attributes,
3802                         &info, &fsp);
3803         } else {
3804
3805                 /*
3806                  * Ordinary file case.
3807                  */
3808
3809                 status = file_new(req, conn, &fsp);
3810                 if(!NT_STATUS_IS_OK(status)) {
3811                         goto fail;
3812                 }
3813
3814                 status = fsp_set_smb_fname(fsp, smb_fname);
3815                 if (!NT_STATUS_IS_OK(status)) {
3816                         goto fail;
3817                 }
3818
3819                 if (base_fsp) {
3820                         /*
3821                          * We're opening the stream element of a
3822                          * base_fsp we already opened. Set up the
3823                          * base_fsp pointer.
3824                          */
3825                         fsp->base_fsp = base_fsp;
3826                 }
3827
3828                 if (allocation_size) {
3829                         fsp->initial_allocation_size = smb_roundup(fsp->conn,
3830                                                         allocation_size);
3831                 }
3832
3833                 status = open_file_ntcreate(conn,
3834                                             req,
3835                                             access_mask,
3836                                             share_access,
3837                                             create_disposition,
3838                                             create_options,
3839                                             file_attributes,
3840                                             oplock_request,
3841                                             private_flags,
3842                                             &info,
3843                                             fsp);
3844
3845                 if(!NT_STATUS_IS_OK(status)) {
3846                         file_free(req, fsp);
3847                         fsp = NULL;
3848                 }
3849
3850                 if (NT_STATUS_EQUAL(status, NT_STATUS_FILE_IS_A_DIRECTORY)) {
3851
3852                         /* A stream open never opens a directory */
3853
3854                         if (base_fsp) {
3855                                 status = NT_STATUS_FILE_IS_A_DIRECTORY;
3856                                 goto fail;
3857                         }
3858
3859                         /*
3860                          * Fail the open if it was explicitly a non-directory
3861                          * file.
3862                          */
3863
3864                         if (create_options & FILE_NON_DIRECTORY_FILE) {
3865                                 status = NT_STATUS_FILE_IS_A_DIRECTORY;
3866                                 goto fail;
3867                         }
3868
3869                         oplock_request = 0;
3870                         status = open_directory(
3871                                 conn, req, smb_fname, access_mask,
3872                                 share_access, create_disposition,
3873                                 create_options, file_attributes,
3874                                 &info, &fsp);
3875                 }
3876         }
3877
3878         if (!NT_STATUS_IS_OK(status)) {
3879                 goto fail;
3880         }
3881
3882         fsp->base_fsp = base_fsp;
3883
3884         if ((ea_list != NULL) &&
3885             ((info == FILE_WAS_CREATED) || (info == FILE_WAS_OVERWRITTEN))) {
3886                 status = set_ea(conn, fsp, fsp->fsp_name, ea_list);
3887                 if (!NT_STATUS_IS_OK(status)) {
3888                         goto fail;
3889                 }
3890         }
3891
3892         if (!fsp->is_directory && S_ISDIR(fsp->fsp_name->st.st_ex_mode)) {
3893                 status = NT_STATUS_ACCESS_DENIED;
3894                 goto fail;
3895         }
3896
3897         /* Save the requested allocation size. */
3898         if ((info == FILE_WAS_CREATED) || (info == FILE_WAS_OVERWRITTEN)) {
3899                 if (allocation_size
3900                     && (allocation_size > fsp->fsp_name->st.st_ex_size)) {
3901                         fsp->initial_allocation_size = smb_roundup(
3902                                 fsp->conn, allocation_size);
3903                         if (fsp->is_directory) {
3904                                 /* Can't set allocation size on a directory. */
3905                                 status = NT_STATUS_ACCESS_DENIED;
3906                                 goto fail;
3907                         }
3908                         if (vfs_allocate_file_space(
3909                                     fsp, fsp->initial_allocation_size) == -1) {
3910                                 status = NT_STATUS_DISK_FULL;
3911                                 goto fail;
3912                         }
3913                 } else {
3914                         fsp->initial_allocation_size = smb_roundup(
3915                                 fsp->conn, (uint64_t)fsp->fsp_name->st.st_ex_size);
3916                 }
3917         } else {
3918                 fsp->initial_allocation_size = 0;
3919         }
3920
3921         if ((info == FILE_WAS_CREATED) && lp_nt_acl_support(SNUM(conn)) &&
3922                                 fsp->base_fsp == NULL) {
3923                 if (sd != NULL) {
3924                         /*
3925                          * According to the MS documentation, the only time the security
3926                          * descriptor is applied to the opened file is iff we *created* the
3927                          * file; an existing file stays the same.
3928                          *
3929                          * Also, it seems (from observation) that you can open the file with
3930                          * any access mask but you can still write the sd. We need to override
3931                          * the granted access before we call set_sd
3932                          * Patch for bug #2242 from Tom Lackemann <cessnatomny@yahoo.com>.
3933                          */
3934
3935                         uint32_t sec_info_sent;
3936                         uint32_t saved_access_mask = fsp->access_mask;
3937
3938                         sec_info_sent = get_sec_info(sd);
3939
3940                         fsp->access_mask = FILE_GENERIC_ALL;
3941
3942                         if (sec_info_sent & (SECINFO_OWNER|
3943                                                 SECINFO_GROUP|
3944                                                 SECINFO_DACL|
3945                                                 SECINFO_SACL)) {
3946                                 status = set_sd(fsp, sd, sec_info_sent);
3947                         }
3948
3949                         fsp->access_mask = saved_access_mask;
3950
3951                         if (!NT_STATUS_IS_OK(status)) {
3952                                 goto fail;
3953                         }
3954                 } else if (lp_inherit_acls(SNUM(conn))) {
3955                         /* Inherit from parent. Errors here are not fatal. */
3956                         status = inherit_new_acl(fsp);
3957                         if (!NT_STATUS_IS_OK(status)) {
3958                                 DEBUG(10,("inherit_new_acl: failed for %s with %s\n",
3959                                         fsp_str_dbg(fsp),
3960                                         nt_errstr(status) ));
3961                         }
3962                 }
3963         }
3964
3965         DEBUG(10, ("create_file_unixpath: info=%d\n", info));
3966
3967         *result = fsp;
3968         if (pinfo != NULL) {
3969                 *pinfo = info;
3970         }
3971
3972         smb_fname->st = fsp->fsp_name->st;
3973
3974         return NT_STATUS_OK;
3975
3976  fail:
3977         DEBUG(10, ("create_file_unixpath: %s\n", nt_errstr(status)));
3978
3979         if (fsp != NULL) {
3980                 if (base_fsp && fsp->base_fsp == base_fsp) {
3981                         /*
3982                          * The close_file below will close
3983                          * fsp->base_fsp.
3984                          */
3985                         base_fsp = NULL;
3986                 }
3987                 close_file(req, fsp, ERROR_CLOSE);
3988                 fsp = NULL;
3989         }
3990         if (base_fsp != NULL) {
3991                 close_file(req, base_fsp, ERROR_CLOSE);
3992                 base_fsp = NULL;
3993         }
3994         return status;
3995 }
3996
3997 /*
3998  * Calculate the full path name given a relative fid.
3999  */
4000 NTSTATUS get_relative_fid_filename(connection_struct *conn,
4001                                    struct smb_request *req,
4002                                    uint16_t root_dir_fid,
4003                                    const struct smb_filename *smb_fname,
4004                                    struct smb_filename **smb_fname_out)
4005 {
4006         files_struct *dir_fsp;
4007         char *parent_fname = NULL;
4008         char *new_base_name = NULL;
4009         NTSTATUS status;
4010
4011         if (root_dir_fid == 0 || !smb_fname) {
4012                 status = NT_STATUS_INTERNAL_ERROR;
4013                 goto out;
4014         }
4015
4016         dir_fsp = file_fsp(req, root_dir_fid);
4017
4018         if (dir_fsp == NULL) {
4019                 status = NT_STATUS_INVALID_HANDLE;
4020                 goto out;
4021         }
4022
4023         if (is_ntfs_stream_smb_fname(dir_fsp->fsp_name)) {
4024                 status = NT_STATUS_INVALID_HANDLE;
4025                 goto out;
4026         }
4027
4028         if (!dir_fsp->is_directory) {
4029
4030                 /*
4031                  * Check to see if this is a mac fork of some kind.
4032                  */
4033
4034                 if ((conn->fs_capabilities & FILE_NAMED_STREAMS) &&
4035                     is_ntfs_stream_smb_fname(smb_fname)) {
4036                         status = NT_STATUS_OBJECT_PATH_NOT_FOUND;
4037                         goto out;
4038                 }
4039
4040                 /*
4041                   we need to handle the case when we get a
4042                   relative open relative to a file and the
4043                   pathname is blank - this is a reopen!
4044                   (hint from demyn plantenberg)
4045                 */
4046
4047                 status = NT_STATUS_INVALID_HANDLE;
4048                 goto out;
4049         }
4050
4051         if (ISDOT(dir_fsp->fsp_name->base_name)) {
4052                 /*
4053                  * We're at the toplevel dir, the final file name
4054                  * must not contain ./, as this is filtered out
4055                  * normally by srvstr_get_path and unix_convert
4056                  * explicitly rejects paths containing ./.
4057                  */
4058                 parent_fname = talloc_strdup(talloc_tos(), "");
4059                 if (parent_fname == NULL) {
4060                         status = NT_STATUS_NO_MEMORY;
4061                         goto out;
4062                 }
4063         } else {
4064                 size_t dir_name_len = strlen(dir_fsp->fsp_name->base_name);
4065
4066                 /*
4067                  * Copy in the base directory name.
4068                  */
4069
4070                 parent_fname = talloc_array(talloc_tos(), char,
4071                     dir_name_len+2);
4072                 if (parent_fname == NULL) {
4073                         status = NT_STATUS_NO_MEMORY;
4074                         goto out;
4075                 }
4076                 memcpy(parent_fname, dir_fsp->fsp_name->base_name,
4077                     dir_name_len+1);
4078
4079                 /*
4080                  * Ensure it ends in a '/'.
4081                  * We used TALLOC_SIZE +2 to add space for the '/'.
4082                  */
4083
4084                 if(dir_name_len
4085                     && (parent_fname[dir_name_len-1] != '\\')
4086                     && (parent_fname[dir_name_len-1] != '/')) {
4087                         parent_fname[dir_name_len] = '/';
4088                         parent_fname[dir_name_len+1] = '\0';
4089                 }
4090         }
4091
4092         new_base_name = talloc_asprintf(talloc_tos(), "%s%s", parent_fname,
4093                                         smb_fname->base_name);
4094         if (new_base_name == NULL) {
4095                 status = NT_STATUS_NO_MEMORY;
4096                 goto out;
4097         }
4098
4099         status = filename_convert(req,
4100                                 conn,
4101                                 req->flags2 & FLAGS2_DFS_PATHNAMES,
4102                                 new_base_name,
4103                                 0,
4104                                 NULL,
4105                                 smb_fname_out);
4106         if (!NT_STATUS_IS_OK(status)) {
4107                 goto out;
4108         }
4109
4110  out:
4111         TALLOC_FREE(parent_fname);
4112         TALLOC_FREE(new_base_name);
4113         return status;
4114 }
4115
4116 NTSTATUS create_file_default(connection_struct *conn,
4117                              struct smb_request *req,
4118                              uint16_t root_dir_fid,
4119                              struct smb_filename *smb_fname,
4120                              uint32_t access_mask,
4121                              uint32_t share_access,
4122                              uint32_t create_disposition,
4123                              uint32_t create_options,
4124                              uint32_t file_attributes,
4125                              uint32_t oplock_request,
4126                              uint64_t allocation_size,
4127                              uint32_t private_flags,
4128                              struct security_descriptor *sd,
4129                              struct ea_list *ea_list,
4130                              files_struct **result,
4131                              int *pinfo)
4132 {
4133         int info = FILE_WAS_OPENED;
4134         files_struct *fsp = NULL;
4135         NTSTATUS status;
4136         bool stream_name = false;
4137
4138         DEBUG(10,("create_file: access_mask = 0x%x "
4139                   "file_attributes = 0x%x, share_access = 0x%x, "
4140                   "create_disposition = 0x%x create_options = 0x%x "
4141                   "oplock_request = 0x%x "
4142                   "private_flags = 0x%x "
4143                   "root_dir_fid = 0x%x, ea_list = 0x%p, sd = 0x%p, "
4144                   "fname = %s\n",
4145                   (unsigned int)access_mask,
4146                   (unsigned int)file_attributes,
4147                   (unsigned int)share_access,
4148                   (unsigned int)create_disposition,
4149                   (unsigned int)create_options,
4150                   (unsigned int)oplock_request,
4151                   (unsigned int)private_flags,
4152                   (unsigned int)root_dir_fid,
4153                   ea_list, sd, smb_fname_str_dbg(smb_fname)));
4154
4155         /*
4156          * Calculate the filename from the root_dir_if if necessary.
4157          */
4158
4159         if (root_dir_fid != 0) {
4160                 struct smb_filename *smb_fname_out = NULL;
4161                 status = get_relative_fid_filename(conn, req, root_dir_fid,
4162                                                    smb_fname, &smb_fname_out);
4163                 if (!NT_STATUS_IS_OK(status)) {
4164                         goto fail;
4165                 }
4166                 smb_fname = smb_fname_out;
4167         }
4168
4169         /*
4170          * Check to see if this is a mac fork of some kind.
4171          */
4172
4173         stream_name = is_ntfs_stream_smb_fname(smb_fname);
4174         if (stream_name) {
4175                 enum FAKE_FILE_TYPE fake_file_type;
4176
4177                 fake_file_type = is_fake_file(smb_fname);
4178
4179                 if (fake_file_type != FAKE_FILE_TYPE_NONE) {
4180
4181                         /*
4182                          * Here we go! support for changing the disk quotas
4183                          * --metze
4184                          *
4185                          * We need to fake up to open this MAGIC QUOTA file
4186                          * and return a valid FID.
4187                          *
4188                          * w2k close this file directly after openening xp
4189                          * also tries a QUERY_FILE_INFO on the file and then
4190                          * close it
4191                          */
4192                         status = open_fake_file(req, conn, req->vuid,
4193                                                 fake_file_type, smb_fname,
4194                                                 access_mask, &fsp);
4195                         if (!NT_STATUS_IS_OK(status)) {
4196                                 goto fail;
4197                         }
4198
4199                         ZERO_STRUCT(smb_fname->st);
4200                         goto done;
4201                 }
4202
4203                 if (!(conn->fs_capabilities & FILE_NAMED_STREAMS)) {
4204                         status = NT_STATUS_OBJECT_NAME_NOT_FOUND;
4205                         goto fail;
4206                 }
4207         }
4208
4209         if (is_ntfs_default_stream_smb_fname(smb_fname)) {
4210                 int ret;
4211                 smb_fname->stream_name = NULL;
4212                 /* We have to handle this error here. */
4213                 if (create_options & FILE_DIRECTORY_FILE) {
4214                         status = NT_STATUS_NOT_A_DIRECTORY;
4215                         goto fail;
4216                 }
4217                 if (lp_posix_pathnames()) {
4218                         ret = SMB_VFS_LSTAT(conn, smb_fname);
4219                 } else {
4220                         ret = SMB_VFS_STAT(conn, smb_fname);
4221                 }
4222
4223                 if (ret == 0 && VALID_STAT_OF_DIR(smb_fname->st)) {
4224                         status = NT_STATUS_FILE_IS_A_DIRECTORY;
4225                         goto fail;
4226                 }
4227         }
4228
4229         status = create_file_unixpath(
4230                 conn, req, smb_fname, access_mask, share_access,
4231                 create_disposition, create_options, file_attributes,
4232                 oplock_request, allocation_size, private_flags,
4233                 sd, ea_list,
4234                 &fsp, &info);
4235
4236         if (!NT_STATUS_IS_OK(status)) {
4237                 goto fail;
4238         }
4239
4240  done:
4241         DEBUG(10, ("create_file: info=%d\n", info));
4242
4243         *result = fsp;
4244         if (pinfo != NULL) {
4245                 *pinfo = info;
4246         }
4247         return NT_STATUS_OK;
4248
4249  fail:
4250         DEBUG(10, ("create_file: %s\n", nt_errstr(status)));
4251
4252         if (fsp != NULL) {
4253                 close_file(req, fsp, ERROR_CLOSE);
4254                 fsp = NULL;
4255         }
4256         return status;
4257 }