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    Copyright (C) Ralph Boehme 2017
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  21 */
  22
  23 #include "includes.h"
  24 #include "smb1_utils.h"
  25 #include "system/filesys.h"
  26 #include "lib/util/server_id.h"
  27 #include "printing.h"
  28 #include "smbd/smbd.h"
  29 #include "smbd/globals.h"
  30 #include "fake_file.h"
  31 #include "../libcli/security/security.h"
  32 #include "../librpc/gen_ndr/ndr_security.h"
  33 #include "../librpc/gen_ndr/ndr_open_files.h"
  34 #include "../librpc/gen_ndr/idmap.h"
  35 #include "../librpc/gen_ndr/ioctl.h"
  36 #include "passdb/lookup_sid.h"
  37 #include "auth.h"
  38 #include "serverid.h"
  39 #include "messages.h"
  40 #include "source3/lib/dbwrap/dbwrap_watch.h"
  41 #include "locking/leases_db.h"
  42 #include "librpc/gen_ndr/ndr_leases_db.h"
  43 #include "lib/util/time_basic.h"
  44
  45 extern const struct generic_mapping file_generic_mapping;
  46
  47 struct deferred_open_record {
  48         struct smbXsrv_connection *xconn;
  49         uint64_t mid;
  50
  51         bool async_open;
  52
  53         /*
  54          * Timer for async opens, needed because they don't use a watch on
  55          * a locking.tdb record. This is currently only used for real async
  56          * opens and just terminates smbd if the async open times out.
  57          */
  58         struct tevent_timer *te;
  59
  60         /*
  61          * For the samba kernel oplock case we use both a timeout and
  62          * a watch on locking.tdb. This way in case it's smbd holding
  63          * the kernel oplock we get directly notified for the retry
  64          * once the kernel oplock is properly broken. Store the req
  65          * here so that it can be timely discarded once the timer
  66          * above fires.
  67          */
  68         struct tevent_req *watch_req;
  69 };
  70
  71 /****************************************************************************
  72  If the requester wanted DELETE_ACCESS and was rejected because
  73  the file ACL didn't include DELETE_ACCESS, see if the parent ACL
  74  overrides this.
  75 ****************************************************************************/
  76
  77 static bool parent_override_delete(connection_struct *conn,
  78                                         const struct smb_filename *smb_fname,
  79                                         uint32_t access_mask,
  80                                         uint32_t rejected_mask)
  81 {
  82         if ((access_mask & DELETE_ACCESS) &&
  83                     (rejected_mask & DELETE_ACCESS) &&
  84                     can_delete_file_in_directory(conn, smb_fname)) {
  85                 return true;
  86         }
  87         return false;
  88 }
  89
  90 /****************************************************************************
  91  Check if we have open rights.
  92 ****************************************************************************/
  93
  94 NTSTATUS smbd_check_access_rights(struct connection_struct *conn,
  95                                 const struct smb_filename *smb_fname,
  96                                 bool use_privs,
  97                                 uint32_t access_mask)
  98 {
  99         /* Check if we have rights to open. */
 100         NTSTATUS status;
 101         struct security_descriptor *sd = NULL;
 102         uint32_t rejected_share_access;
 103         uint32_t rejected_mask = access_mask;
 104         uint32_t do_not_check_mask = 0;
 105
 106         rejected_share_access = access_mask & ~(conn->share_access);
 107
 108         if (rejected_share_access) {
 109                 DEBUG(10, ("smbd_check_access_rights: rejected share access 0x%x "
 110                         "on %s (0x%x)\n",
 111                         (unsigned int)access_mask,
 112                         smb_fname_str_dbg(smb_fname),
 113                         (unsigned int)rejected_share_access ));
 114                 return NT_STATUS_ACCESS_DENIED;
 115         }
 116
 117         if (!use_privs && get_current_uid(conn) == (uid_t)0) {
 118                 /* I'm sorry sir, I didn't know you were root... */
 119                 DEBUG(10,("smbd_check_access_rights: root override "
 120                         "on %s. Granting 0x%x\n",
 121                         smb_fname_str_dbg(smb_fname),
 122                         (unsigned int)access_mask ));
 123                 return NT_STATUS_OK;
 124         }
 125
 126         if ((access_mask & DELETE_ACCESS) && !lp_acl_check_permissions(SNUM(conn))) {
 127                 DEBUG(10,("smbd_check_access_rights: not checking ACL "
 128                         "on DELETE_ACCESS on file %s. Granting 0x%x\n",
 129                         smb_fname_str_dbg(smb_fname),
 130                         (unsigned int)access_mask ));
 131                 return NT_STATUS_OK;
 132         }
 133
 134         if (access_mask == DELETE_ACCESS &&
 135                         VALID_STAT(smb_fname->st) &&
 136                         S_ISLNK(smb_fname->st.st_ex_mode)) {
 137                 /* We can always delete a symlink. */
 138                 DEBUG(10,("smbd_check_access_rights: not checking ACL "
 139                         "on DELETE_ACCESS on symlink %s.\n",
 140                         smb_fname_str_dbg(smb_fname) ));
 141                 return NT_STATUS_OK;
 142         }
 143
 144         status = SMB_VFS_GET_NT_ACL(conn, smb_fname,
 145                         (SECINFO_OWNER |
 146                         SECINFO_GROUP |
 147                          SECINFO_DACL), talloc_tos(), &sd);
 148
 149         if (!NT_STATUS_IS_OK(status)) {
 150                 DEBUG(10, ("smbd_check_access_rights: Could not get acl "
 151                         "on %s: %s\n",
 152                         smb_fname_str_dbg(smb_fname),
 153                         nt_errstr(status)));
 154
 155                 if (NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED)) {
 156                         goto access_denied;
 157                 }
 158
 159                 return status;
 160         }
 161
 162         /*
 163          * If we can access the path to this file, by
 164          * default we have FILE_READ_ATTRIBUTES from the
 165          * containing directory. See the section:
 166          * "Algorithm to Check Access to an Existing File"
 167          * in MS-FSA.pdf.
 168          *
 169          * se_file_access_check() also takes care of
 170          * owner WRITE_DAC and READ_CONTROL.
 171          */
 172         do_not_check_mask = FILE_READ_ATTRIBUTES;
 173
 174         /*
 175          * Samba 3.6 and earlier granted execute access even
 176          * if the ACL did not contain execute rights.
 177          * Samba 4.0 is more correct and checks it.
 178          * The compatibilty mode allows one to skip this check
 179          * to smoothen upgrades.
 180          */
 181         if (lp_acl_allow_execute_always(SNUM(conn))) {
 182                 do_not_check_mask |= FILE_EXECUTE;
 183         }
 184
 185         status = se_file_access_check(sd,
 186                                 get_current_nttok(conn),
 187                                 use_privs,
 188                                 (access_mask & ~do_not_check_mask),
 189                                 &rejected_mask);
 190
 191         DEBUG(10,("smbd_check_access_rights: file %s requesting "
 192                 "0x%x returning 0x%x (%s)\n",
 193                 smb_fname_str_dbg(smb_fname),
 194                 (unsigned int)access_mask,
 195                 (unsigned int)rejected_mask,
 196                 nt_errstr(status) ));
 197
 198         if (!NT_STATUS_IS_OK(status)) {
 199                 if (DEBUGLEVEL >= 10) {
 200                         DEBUG(10,("smbd_check_access_rights: acl for %s is:\n",
 201                                 smb_fname_str_dbg(smb_fname) ));
 202                         NDR_PRINT_DEBUG(security_descriptor, sd);
 203                 }
 204         }
 205
 206         TALLOC_FREE(sd);
 207
 208         if (NT_STATUS_IS_OK(status) ||
 209                         !NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED)) {
 210                 return status;
 211         }
 212
 213         /* Here we know status == NT_STATUS_ACCESS_DENIED. */
 214
 215   access_denied:
 216
 217         if ((access_mask & FILE_WRITE_ATTRIBUTES) &&
 218                         (rejected_mask & FILE_WRITE_ATTRIBUTES) &&
 219                         !lp_store_dos_attributes(SNUM(conn)) &&
 220                         (lp_map_readonly(SNUM(conn)) ||
 221                         lp_map_archive(SNUM(conn)) ||
 222                         lp_map_hidden(SNUM(conn)) ||
 223                         lp_map_system(SNUM(conn)))) {
 224                 rejected_mask &= ~FILE_WRITE_ATTRIBUTES;
 225
 226                 DEBUG(10,("smbd_check_access_rights: "
 227                         "overrode "
 228                         "FILE_WRITE_ATTRIBUTES "
 229                         "on file %s\n",
 230                         smb_fname_str_dbg(smb_fname)));
 231         }
 232
 233         if (parent_override_delete(conn,
 234                                 smb_fname,
 235                                 access_mask,
 236                                 rejected_mask)) {
 237                 /* Were we trying to do an open
 238                  * for delete and didn't get DELETE
 239                  * access (only) ? Check if the
 240                  * directory allows DELETE_CHILD.
 241                  * See here:
 242                  * http://blogs.msdn.com/oldnewthing/archive/2004/06/04/148426.aspx
 243                  * for details. */
 244
 245                 rejected_mask &= ~DELETE_ACCESS;
 246
 247                 DEBUG(10,("smbd_check_access_rights: "
 248                         "overrode "
 249                         "DELETE_ACCESS on "
 250                         "file %s\n",
 251                         smb_fname_str_dbg(smb_fname)));
 252         }
 253
 254         if (rejected_mask != 0) {
 255                 return NT_STATUS_ACCESS_DENIED;
 256         }
 257         return NT_STATUS_OK;
 258 }
 259
 260 NTSTATUS check_parent_access(struct connection_struct *conn,
 261                                 struct smb_filename *smb_fname,
 262                                 uint32_t access_mask)
 263 {
 264         NTSTATUS status;
 265         char *parent_dir = NULL;
 266         struct security_descriptor *parent_sd = NULL;
 267         uint32_t access_granted = 0;
 268         struct smb_filename *parent_smb_fname = NULL;
 269         struct share_mode_lock *lck = NULL;
 270         struct file_id id = {0};
 271         uint32_t name_hash;
 272         bool delete_on_close_set;
 273         int ret;
 274         TALLOC_CTX *frame = talloc_stackframe();
 275
 276         if (!parent_dirname(frame,
 277                                 smb_fname->base_name,
 278                                 &parent_dir,
 279                                 NULL)) {
 280                 status = NT_STATUS_NO_MEMORY;
 281                 goto out;
 282         }
 283
 284         parent_smb_fname = synthetic_smb_fname(frame,
 285                                 parent_dir,
 286                                 NULL,
 287                                 NULL,
 288                                 smb_fname->flags);
 289         if (parent_smb_fname == NULL) {
 290                 status = NT_STATUS_NO_MEMORY;
 291                 goto out;
 292         }
 293
 294         if (get_current_uid(conn) == (uid_t)0) {
 295                 /* I'm sorry sir, I didn't know you were root... */
 296                 DEBUG(10,("check_parent_access: root override "
 297                         "on %s. Granting 0x%x\n",
 298                         smb_fname_str_dbg(smb_fname),
 299                         (unsigned int)access_mask ));
 300                 status = NT_STATUS_OK;
 301                 goto out;
 302         }
 303
 304         status = SMB_VFS_GET_NT_ACL(conn,
 305                                 parent_smb_fname,
 306                                 SECINFO_DACL,
 307                                 frame,
 308                                 &parent_sd);
 309
 310         if (!NT_STATUS_IS_OK(status)) {
 311                 DEBUG(5,("check_parent_access: SMB_VFS_GET_NT_ACL failed for "
 312                         "%s with error %s\n",
 313                         parent_dir,
 314                         nt_errstr(status)));
 315                 goto out;
 316         }
 317
 318         /*
 319          * If we can access the path to this file, by
 320          * default we have FILE_READ_ATTRIBUTES from the
 321          * containing directory. See the section:
 322          * "Algorithm to Check Access to an Existing File"
 323          * in MS-FSA.pdf.
 324          *
 325          * se_file_access_check() also takes care of
 326          * owner WRITE_DAC and READ_CONTROL.
 327          */
 328         status = se_file_access_check(parent_sd,
 329                                 get_current_nttok(conn),
 330                                 false,
 331                                 (access_mask & ~FILE_READ_ATTRIBUTES),
 332                                 &access_granted);
 333         if(!NT_STATUS_IS_OK(status)) {
 334                 DEBUG(5,("check_parent_access: access check "
 335                         "on directory %s for "
 336                         "path %s for mask 0x%x returned (0x%x) %s\n",
 337                         parent_dir,
 338                         smb_fname->base_name,
 339                         access_mask,
 340                         access_granted,
 341                         nt_errstr(status) ));
 342                 goto out;
 343         }
 344
 345         if (!(access_mask & (SEC_DIR_ADD_FILE | SEC_DIR_ADD_SUBDIR))) {
 346                 status = NT_STATUS_OK;
 347                 goto out;
 348         }
 349         if (!lp_check_parent_directory_delete_on_close(SNUM(conn))) {
 350                 status = NT_STATUS_OK;
 351                 goto out;
 352         }
 353
 354         /* Check if the directory has delete-on-close set */
 355         ret = SMB_VFS_STAT(conn, parent_smb_fname);
 356         if (ret != 0) {
 357                 status = map_nt_error_from_unix(errno);
 358                 goto out;
 359         }
 360
 361         id = SMB_VFS_FILE_ID_CREATE(conn, &parent_smb_fname->st);
 362
 363         status = file_name_hash(conn, parent_smb_fname->base_name, &name_hash);
 364         if (!NT_STATUS_IS_OK(status)) {
 365                 goto out;
 366         }
 367
 368         lck = get_existing_share_mode_lock(frame, id);
 369         if (lck == NULL) {
 370                 status = NT_STATUS_OK;
 371                 goto out;
 372         }
 373
 374         delete_on_close_set = is_delete_on_close_set(lck, name_hash);
 375         if (delete_on_close_set) {
 376                 status = NT_STATUS_DELETE_PENDING;
 377                 goto out;
 378         }
 379
 380         status = NT_STATUS_OK;
 381
 382 out:
 383         TALLOC_FREE(frame);
 384         return status;
 385 }
 386
 387 /****************************************************************************
 388  Ensure when opening a base file for a stream open that we have permissions
 389  to do so given the access mask on the base file.
 390 ****************************************************************************/
 391
 392 static NTSTATUS check_base_file_access(struct connection_struct *conn,
 393                                 struct smb_filename *smb_fname,
 394                                 uint32_t access_mask)
 395 {
 396         NTSTATUS status;
 397
 398         status = smbd_calculate_access_mask(conn, smb_fname,
 399                                         false,
 400                                         access_mask,
 401                                         &access_mask);
 402         if (!NT_STATUS_IS_OK(status)) {
 403                 DEBUG(10, ("smbd_calculate_access_mask "
 404                         "on file %s returned %s\n",
 405                         smb_fname_str_dbg(smb_fname),
 406                         nt_errstr(status)));
 407                 return status;
 408         }
 409
 410         if (access_mask & (FILE_WRITE_DATA|FILE_APPEND_DATA)) {
 411                 uint32_t dosattrs;
 412                 if (!CAN_WRITE(conn)) {
 413                         return NT_STATUS_ACCESS_DENIED;
 414                 }
 415                 dosattrs = dos_mode(conn, smb_fname);
 416                 if (IS_DOS_READONLY(dosattrs)) {
 417                         return NT_STATUS_ACCESS_DENIED;
 418                 }
 419         }
 420
 421         return smbd_check_access_rights(conn,
 422                                         smb_fname,
 423                                         false,
 424                                         access_mask);
 425 }
 426
 427 /****************************************************************************
 428  Handle differing symlink errno's
 429 ****************************************************************************/
 430
 431 static int link_errno_convert(int err)
 432 {
 433 #if defined(ENOTSUP) && defined(OSF1)
 434         /* handle special Tru64 errno */
 435         if (err == ENOTSUP) {
 436                 err = ELOOP;
 437         }
 438 #endif /* ENOTSUP */
 439 #ifdef EFTYPE
 440         /* fix broken NetBSD errno */
 441         if (err == EFTYPE) {
 442                 err = ELOOP;
 443         }
 444 #endif /* EFTYPE */
 445         /* fix broken FreeBSD errno */
 446         if (err == EMLINK) {
 447                 err = ELOOP;
 448         }
 449         return err;
 450 }
 451
 452 static int non_widelink_open(struct connection_struct *conn,
 453                         const struct smb_filename *conn_rootdir_fname,
 454                         files_struct *fsp,
 455                         struct smb_filename *smb_fname,
 456                         int flags,
 457                         mode_t mode,
 458                         unsigned int link_depth);
 459
 460 /****************************************************************************
 461  Follow a symlink in userspace.
 462 ****************************************************************************/
 463
 464 static int process_symlink_open(struct connection_struct *conn,
 465                         const struct smb_filename *conn_rootdir_fname,
 466                         files_struct *fsp,
 467                         struct smb_filename *smb_fname,
 468                         int flags,
 469                         mode_t mode,
 470                         unsigned int link_depth)
 471 {
 472         int fd = -1;
 473         char *link_target = NULL;
 474         struct smb_filename target_fname = {0};
 475         int link_len = -1;
 476         struct smb_filename *oldwd_fname = NULL;
 477         size_t rootdir_len = 0;
 478         struct smb_filename *resolved_fname = NULL;
 479         char *resolved_name = NULL;
 480         bool matched = false;
 481         int saved_errno = 0;
 482
 483         /*
 484          * Ensure we don't get stuck in a symlink loop.
 485          */
 486         link_depth++;
 487         if (link_depth >= 20) {
 488                 errno = ELOOP;
 489                 goto out;
 490         }
 491
 492         /* Allocate space for the link target. */
 493         link_target = talloc_array(talloc_tos(), char, PATH_MAX);
 494         if (link_target == NULL) {
 495                 errno = ENOMEM;
 496                 goto out;
 497         }
 498
 499         /* Read the link target. */
 500         link_len = SMB_VFS_READLINKAT(conn,
 501                                 conn->cwd_fsp,
 502                                 smb_fname,
 503                                 link_target,
 504                                 PATH_MAX - 1);
 505         if (link_len == -1) {
 506                 goto out;
 507         }
 508
 509         /* Ensure it's at least null terminated. */
 510         link_target[link_len] = '\0';
 511         target_fname = (struct smb_filename){ .base_name = link_target };
 512
 513         /* Convert to an absolute path. */
 514         resolved_fname = SMB_VFS_REALPATH(conn, talloc_tos(), &target_fname);
 515         if (resolved_fname == NULL) {
 516                 goto out;
 517         }
 518         resolved_name = resolved_fname->base_name;
 519
 520         /*
 521          * We know conn_rootdir starts with '/' and
 522          * does not end in '/'. FIXME ! Should we
 523          * smb_assert this ?
 524          */
 525         rootdir_len = strlen(conn_rootdir_fname->base_name);
 526
 527         matched = (strncmp(conn_rootdir_fname->base_name,
 528                                 resolved_name,
 529                                 rootdir_len) == 0);
 530         if (!matched) {
 531                 errno = EACCES;
 532                 goto out;
 533         }
 534
 535         /*
 536          * Turn into a path relative to the share root.
 537          */
 538         if (resolved_name[rootdir_len] == '\0') {
 539                 /* Link to the root of the share. */
 540                 TALLOC_FREE(smb_fname->base_name);
 541                 smb_fname->base_name = talloc_strdup(smb_fname, ".");
 542         } else if (resolved_name[rootdir_len] == '/') {
 543                 TALLOC_FREE(smb_fname->base_name);
 544                 smb_fname->base_name = talloc_strdup(smb_fname,
 545                                         &resolved_name[rootdir_len+1]);
 546         } else {
 547                 errno = EACCES;
 548                 goto out;
 549         }
 550
 551         if (smb_fname->base_name == NULL) {
 552                 errno = ENOMEM;
 553                 goto out;
 554         }
 555
 556         oldwd_fname = vfs_GetWd(talloc_tos(), conn);
 557         if (oldwd_fname == NULL) {
 558                 goto out;
 559         }
 560
 561         /* Ensure we operate from the root of the share. */
 562         if (vfs_ChDir(conn, conn_rootdir_fname) == -1) {
 563                 goto out;
 564         }
 565
 566         /* And do it all again.. */
 567         fd = non_widelink_open(conn,
 568                                 conn_rootdir_fname,
 569                                 fsp,
 570                                 smb_fname,
 571                                 flags,
 572                                 mode,
 573                                 link_depth);
 574         if (fd == -1) {
 575                 saved_errno = errno;
 576         }
 577
 578   out:
 579
 580         TALLOC_FREE(resolved_fname);
 581         TALLOC_FREE(link_target);
 582         if (oldwd_fname != NULL) {
 583                 int ret = vfs_ChDir(conn, oldwd_fname);
 584                 if (ret == -1) {
 585                         smb_panic("unable to get back to old directory\n");
 586                 }
 587                 TALLOC_FREE(oldwd_fname);
 588         }
 589         if (saved_errno != 0) {
 590                 errno = saved_errno;
 591         }
 592         return fd;
 593 }
 594
 595 /****************************************************************************
 596  Non-widelink open.
 597 ****************************************************************************/
 598
 599 static int non_widelink_open(struct connection_struct *conn,
 600                         const struct smb_filename *conn_rootdir_fname,
 601                         files_struct *fsp,
 602                         struct smb_filename *smb_fname,
 603                         int flags,
 604                         mode_t mode,
 605                         unsigned int link_depth)
 606 {
 607         NTSTATUS status;
 608         int fd = -1;
 609         struct smb_filename *smb_fname_rel = NULL;
 610         int saved_errno = 0;
 611         struct smb_filename *oldwd_fname = NULL;
 612         char *parent_dir = NULL;
 613         struct smb_filename parent_dir_fname = {0};
 614         const char *final_component = NULL;
 615         bool is_directory = false;
 616         bool ok;
 617
 618 #ifdef O_DIRECTORY
 619         if (flags & O_DIRECTORY) {
 620                 is_directory = true;
 621         }
 622 #endif
 623
 624         if (is_directory) {
 625                 parent_dir = talloc_strdup(talloc_tos(), smb_fname->base_name);
 626                 if (parent_dir == NULL) {
 627                         saved_errno = errno;
 628                         goto out;
 629                 }
 630
 631                 final_component = ".";
 632         } else {
 633                 ok = parent_dirname(talloc_tos(),
 634                                     smb_fname->base_name,
 635                                     &parent_dir,
 636                                     &final_component);
 637                 if (!ok) {
 638                         saved_errno = errno;
 639                         goto out;
 640                 }
 641         }
 642
 643         parent_dir_fname = (struct smb_filename) { .base_name = parent_dir };
 644
 645         oldwd_fname = vfs_GetWd(talloc_tos(), conn);
 646         if (oldwd_fname == NULL) {
 647                 goto out;
 648         }
 649
 650         /* Pin parent directory in place. */
 651         if (vfs_ChDir(conn, &parent_dir_fname) == -1) {
 652                 goto out;
 653         }
 654
 655         smb_fname_rel = synthetic_smb_fname(talloc_tos(),
 656                                 final_component,
 657                                 smb_fname->stream_name,
 658                                 &smb_fname->st,
 659                                 smb_fname->flags);
 660         if (smb_fname_rel == NULL) {
 661                 saved_errno = ENOMEM;
 662                 goto out;
 663         }
 664
 665         /* Ensure the relative path is below the share. */
 666         status = check_reduced_name(conn, &parent_dir_fname, smb_fname_rel);
 667         if (!NT_STATUS_IS_OK(status)) {
 668                 saved_errno = map_errno_from_nt_status(status);
 669                 goto out;
 670         }
 671
 672         flags |= O_NOFOLLOW;
 673
 674         {
 675                 struct smb_filename *tmp_name = fsp->fsp_name;
 676                 fsp->fsp_name = smb_fname_rel;
 677                 fd = SMB_VFS_OPEN(conn, smb_fname_rel, fsp, flags, mode);
 678                 fsp->fsp_name = tmp_name;
 679         }
 680
 681         if (fd == -1) {
 682                 saved_errno = link_errno_convert(errno);
 683                 /*
 684                  * Trying to open a symlink to a directory with O_NOFOLLOW and
 685                  * O_DIRECTORY can return either of ELOOP and ENOTDIR. So
 686                  * ENOTDIR really means: might be a symlink, but we're not sure.
 687                  * In this case, we just assume there's a symlink. If we were
 688                  * wrong, process_symlink_open() will return EINVAL. We check
 689                  * this below, and fall back to returning the initial
 690                  * saved_errno.
 691                  *
 692                  * BUG: https://bugzilla.samba.org/show_bug.cgi?id=12860
 693                  */
 694                 if (saved_errno == ELOOP || saved_errno == ENOTDIR) {
 695                         if (fsp->posix_flags & FSP_POSIX_FLAGS_OPEN) {
 696                                 /* Never follow symlinks on posix open. */
 697                                 goto out;
 698                         }
 699                         if (!lp_follow_symlinks(SNUM(conn))) {
 700                                 /* Explicitly no symlinks. */
 701                                 goto out;
 702                         }
 703                         /*
 704                          * We may have a symlink. Follow in userspace
 705                          * to ensure it's under the share definition.
 706                          */
 707                         fd = process_symlink_open(conn,
 708                                         conn_rootdir_fname,
 709                                         fsp,
 710                                         smb_fname_rel,
 711                                         flags,
 712                                         mode,
 713                                         link_depth);
 714                         if (fd == -1) {
 715                                 if (saved_errno == ENOTDIR &&
 716                                                 errno == EINVAL) {
 717                                         /*
 718                                          * O_DIRECTORY on neither a directory,
 719                                          * nor a symlink. Just return
 720                                          * saved_errno from initial open()
 721                                          */
 722                                         goto out;
 723                                 }
 724                                 saved_errno =
 725                                         link_errno_convert(errno);
 726                         }
 727                 }
 728         }
 729
 730   out:
 731
 732         TALLOC_FREE(parent_dir);
 733         TALLOC_FREE(smb_fname_rel);
 734
 735         if (oldwd_fname != NULL) {
 736                 int ret = vfs_ChDir(conn, oldwd_fname);
 737                 if (ret == -1) {
 738                         smb_panic("unable to get back to old directory\n");
 739                 }
 740                 TALLOC_FREE(oldwd_fname);
 741         }
 742         if (saved_errno != 0) {
 743                 errno = saved_errno;
 744         }
 745         return fd;
 746 }
 747
 748 /****************************************************************************
 749  fd support routines - attempt to do a dos_open.
 750 ****************************************************************************/
 751
 752 NTSTATUS fd_open(struct connection_struct *conn,
 753                  files_struct *fsp,
 754                  int flags,
 755                  mode_t mode)
 756 {
 757         struct smb_filename *smb_fname = fsp->fsp_name;
 758         NTSTATUS status = NT_STATUS_OK;
 759
 760         /*
 761          * Never follow symlinks on a POSIX client. The
 762          * client should be doing this.
 763          */
 764
 765         if ((fsp->posix_flags & FSP_POSIX_FLAGS_OPEN) || !lp_follow_symlinks(SNUM(conn))) {
 766                 flags |= O_NOFOLLOW;
 767         }
 768
 769         /* Ensure path is below share definition. */
 770         if (!lp_widelinks(SNUM(conn))) {
 771                 struct smb_filename *conn_rootdir_fname = NULL;
 772                 const char *conn_rootdir = SMB_VFS_CONNECTPATH(conn,
 773                                                 smb_fname);
 774                 int saved_errno = 0;
 775
 776                 if (conn_rootdir == NULL) {
 777                         return NT_STATUS_NO_MEMORY;
 778                 }
 779                 conn_rootdir_fname = synthetic_smb_fname(talloc_tos(),
 780                                                 conn_rootdir,
 781                                                 NULL,
 782                                                 NULL,
 783                                                 0);
 784                 if (conn_rootdir_fname == NULL) {
 785                         return NT_STATUS_NO_MEMORY;
 786                 }
 787
 788                 /*
 789                  * Only follow symlinks within a share
 790                  * definition.
 791                  */
 792                 fsp->fh->fd = non_widelink_open(conn,
 793                                         conn_rootdir_fname,
 794                                         fsp,
 795                                         smb_fname,
 796                                         flags,
 797                                         mode,
 798                                         0);
 799                 if (fsp->fh->fd == -1) {
 800                         saved_errno = errno;
 801                 }
 802                 TALLOC_FREE(conn_rootdir_fname);
 803                 if (saved_errno != 0) {
 804                         errno = saved_errno;
 805                 }
 806         } else {
 807                 fsp->fh->fd = SMB_VFS_OPEN(conn, smb_fname, fsp, flags, mode);
 808         }
 809
 810         if (fsp->fh->fd == -1) {
 811                 int posix_errno = link_errno_convert(errno);
 812                 status = map_nt_error_from_unix(posix_errno);
 813                 if (errno == EMFILE) {
 814                         static time_t last_warned = 0L;
 815
 816                         if (time((time_t *) NULL) > last_warned) {
 817                                 DEBUG(0,("Too many open files, unable "
 818                                         "to open more!  smbd's max "
 819                                         "open files = %d\n",
 820                                         lp_max_open_files()));
 821                                 last_warned = time((time_t *) NULL);
 822                         }
 823                 }
 824
 825         }
 826
 827         DEBUG(10,("fd_open: name %s, flags = 0%o mode = 0%o, fd = %d. %s\n",
 828                   smb_fname_str_dbg(smb_fname), flags, (int)mode, fsp->fh->fd,
 829                 (fsp->fh->fd == -1) ? strerror(errno) : "" ));
 830
 831         return status;
 832 }
 833
 834 /****************************************************************************
 835  Close the file associated with a fsp.
 836 ****************************************************************************/
 837
 838 NTSTATUS fd_close(files_struct *fsp)
 839 {
 840         int ret;
 841
 842         if (fsp->dptr) {
 843                 dptr_CloseDir(fsp);
 844         }
 845         if (fsp->fh->fd == -1) {
 846                 /*
 847                  * Either a directory where the dptr_CloseDir() already closed
 848                  * the fd or a stat open.
 849                  */
 850                 return NT_STATUS_OK;
 851         }
 852         if (fsp->fh->ref_count > 1) {
 853                 return NT_STATUS_OK; /* Shared handle. Only close last reference. */
 854         }
 855
 856         ret = SMB_VFS_CLOSE(fsp);
 857         fsp->fh->fd = -1;
 858         if (ret == -1) {
 859                 return map_nt_error_from_unix(errno);
 860         }
 861         return NT_STATUS_OK;
 862 }
 863
 864 /****************************************************************************
 865  Change the ownership of a file to that of the parent directory.
 866  Do this by fd if possible.
 867 ****************************************************************************/
 868
 869 void change_file_owner_to_parent(connection_struct *conn,
 870                                         const char *inherit_from_dir,
 871                                         files_struct *fsp)
 872 {
 873         struct smb_filename *smb_fname_parent;
 874         int ret;
 875
 876         smb_fname_parent = synthetic_smb_fname(talloc_tos(),
 877                                         inherit_from_dir,
 878                                         NULL,
 879                                         NULL,
 880                                         0);
 881         if (smb_fname_parent == NULL) {
 882                 return;
 883         }
 884
 885         ret = SMB_VFS_STAT(conn, smb_fname_parent);
 886         if (ret == -1) {
 887                 DEBUG(0,("change_file_owner_to_parent: failed to stat parent "
 888                          "directory %s. Error was %s\n",
 889                          smb_fname_str_dbg(smb_fname_parent),
 890                          strerror(errno)));
 891                 TALLOC_FREE(smb_fname_parent);
 892                 return;
 893         }
 894
 895         if (smb_fname_parent->st.st_ex_uid == fsp->fsp_name->st.st_ex_uid) {
 896                 /* Already this uid - no need to change. */
 897                 DEBUG(10,("change_file_owner_to_parent: file %s "
 898                         "is already owned by uid %d\n",
 899                         fsp_str_dbg(fsp),
 900                         (int)fsp->fsp_name->st.st_ex_uid ));
 901                 TALLOC_FREE(smb_fname_parent);
 902                 return;
 903         }
 904
 905         become_root();
 906         ret = SMB_VFS_FCHOWN(fsp, smb_fname_parent->st.st_ex_uid, (gid_t)-1);
 907         unbecome_root();
 908         if (ret == -1) {
 909                 DEBUG(0,("change_file_owner_to_parent: failed to fchown "
 910                          "file %s to parent directory uid %u. Error "
 911                          "was %s\n", fsp_str_dbg(fsp),
 912                          (unsigned int)smb_fname_parent->st.st_ex_uid,
 913                          strerror(errno) ));
 914         } else {
 915                 DEBUG(10,("change_file_owner_to_parent: changed new file %s to "
 916                         "parent directory uid %u.\n", fsp_str_dbg(fsp),
 917                         (unsigned int)smb_fname_parent->st.st_ex_uid));
 918                 /* Ensure the uid entry is updated. */
 919                 fsp->fsp_name->st.st_ex_uid = smb_fname_parent->st.st_ex_uid;
 920         }
 921
 922         TALLOC_FREE(smb_fname_parent);
 923 }
 924
 925 static NTSTATUS change_dir_owner_to_parent(connection_struct *conn,
 926                                         const char *inherit_from_dir,
 927                                         struct smb_filename *smb_dname,
 928                                         SMB_STRUCT_STAT *psbuf)
 929 {
 930         struct smb_filename *smb_fname_parent;
 931         struct smb_filename *smb_fname_cwd = NULL;
 932         struct smb_filename *saved_dir_fname = NULL;
 933         TALLOC_CTX *ctx = talloc_tos();
 934         NTSTATUS status = NT_STATUS_OK;
 935         int ret;
 936
 937         smb_fname_parent = synthetic_smb_fname(ctx,
 938                                         inherit_from_dir,
 939                                         NULL,
 940                                         NULL,
 941                                         0);
 942         if (smb_fname_parent == NULL) {
 943                 return NT_STATUS_NO_MEMORY;
 944         }
 945
 946         ret = SMB_VFS_STAT(conn, smb_fname_parent);
 947         if (ret == -1) {
 948                 status = map_nt_error_from_unix(errno);
 949                 DEBUG(0,("change_dir_owner_to_parent: failed to stat parent "
 950                          "directory %s. Error was %s\n",
 951                          smb_fname_str_dbg(smb_fname_parent),
 952                          strerror(errno)));
 953                 goto out;
 954         }
 955
 956         /* We've already done an lstat into psbuf, and we know it's a
 957            directory. If we can cd into the directory and the dev/ino
 958            are the same then we can safely chown without races as
 959            we're locking the directory in place by being in it.  This
 960            should work on any UNIX (thanks tridge :-). JRA.
 961         */
 962
 963         saved_dir_fname = vfs_GetWd(ctx,conn);
 964         if (!saved_dir_fname) {
 965                 status = map_nt_error_from_unix(errno);
 966                 DEBUG(0,("change_dir_owner_to_parent: failed to get "
 967                          "current working directory. Error was %s\n",
 968                          strerror(errno)));
 969                 goto out;
 970         }
 971
 972         /* Chdir into the new path. */
 973         if (vfs_ChDir(conn, smb_dname) == -1) {
 974                 status = map_nt_error_from_unix(errno);
 975                 DEBUG(0,("change_dir_owner_to_parent: failed to change "
 976                          "current working directory to %s. Error "
 977                          "was %s\n", smb_dname->base_name, strerror(errno) ));
 978                 goto chdir;
 979         }
 980
 981         smb_fname_cwd = synthetic_smb_fname(ctx, ".", NULL, NULL, 0);
 982         if (smb_fname_cwd == NULL) {
 983                 status = NT_STATUS_NO_MEMORY;
 984                 goto chdir;
 985         }
 986
 987         ret = SMB_VFS_STAT(conn, smb_fname_cwd);
 988         if (ret == -1) {
 989                 status = map_nt_error_from_unix(errno);
 990                 DEBUG(0,("change_dir_owner_to_parent: failed to stat "
 991                          "directory '.' (%s) Error was %s\n",
 992                          smb_dname->base_name, strerror(errno)));
 993                 goto chdir;
 994         }
 995
 996         /* Ensure we're pointing at the same place. */
 997         if (smb_fname_cwd->st.st_ex_dev != psbuf->st_ex_dev ||
 998             smb_fname_cwd->st.st_ex_ino != psbuf->st_ex_ino) {
 999                 DEBUG(0,("change_dir_owner_to_parent: "
1000                          "device/inode on directory %s changed. "
1001                          "Refusing to chown !\n",
1002                         smb_dname->base_name ));
1003                 status = NT_STATUS_ACCESS_DENIED;
1004                 goto chdir;
1005         }
1006
1007         if (smb_fname_parent->st.st_ex_uid == smb_fname_cwd->st.st_ex_uid) {
1008                 /* Already this uid - no need to change. */
1009                 DEBUG(10,("change_dir_owner_to_parent: directory %s "
1010                         "is already owned by uid %d\n",
1011                         smb_dname->base_name,
1012                         (int)smb_fname_cwd->st.st_ex_uid ));
1013                 status = NT_STATUS_OK;
1014                 goto chdir;
1015         }
1016
1017         become_root();
1018         ret = SMB_VFS_LCHOWN(conn,
1019                         smb_fname_cwd,
1020                         smb_fname_parent->st.st_ex_uid,
1021                         (gid_t)-1);
1022         unbecome_root();
1023         if (ret == -1) {
1024                 status = map_nt_error_from_unix(errno);
1025                 DEBUG(10,("change_dir_owner_to_parent: failed to chown "
1026                           "directory %s to parent directory uid %u. "
1027                           "Error was %s\n",
1028                           smb_dname->base_name,
1029                           (unsigned int)smb_fname_parent->st.st_ex_uid,
1030                           strerror(errno) ));
1031         } else {
1032                 DEBUG(10,("change_dir_owner_to_parent: changed ownership of new "
1033                         "directory %s to parent directory uid %u.\n",
1034                         smb_dname->base_name,
1035                         (unsigned int)smb_fname_parent->st.st_ex_uid ));
1036                 /* Ensure the uid entry is updated. */
1037                 psbuf->st_ex_uid = smb_fname_parent->st.st_ex_uid;
1038         }
1039
1040  chdir:
1041         vfs_ChDir(conn, saved_dir_fname);
1042  out:
1043         TALLOC_FREE(saved_dir_fname);
1044         TALLOC_FREE(smb_fname_parent);
1045         TALLOC_FREE(smb_fname_cwd);
1046         return status;
1047 }
1048
1049 /****************************************************************************
1050  Open a file - returning a guaranteed ATOMIC indication of if the
1051  file was created or not.
1052 ****************************************************************************/
1053
1054 static NTSTATUS fd_open_atomic(struct connection_struct *conn,
1055                         files_struct *fsp,
1056                         int flags,
1057                         mode_t mode,
1058                         bool *file_created)
1059 {
1060         NTSTATUS status = NT_STATUS_UNSUCCESSFUL;
1061         NTSTATUS retry_status;
1062         bool file_existed = VALID_STAT(fsp->fsp_name->st);
1063         int curr_flags;
1064
1065         if (!(flags & O_CREAT)) {
1066                 /*
1067                  * We're not creating the file, just pass through.
1068                  */
1069                 status = fd_open(conn, fsp, flags, mode);
1070                 *file_created = false;
1071                 return status;
1072         }
1073
1074         if (flags & O_EXCL) {
1075                 /*
1076                  * Fail if already exists, just pass through.
1077                  */
1078                 status = fd_open(conn, fsp, flags, mode);
1079
1080                 /*
1081                  * Here we've opened with O_CREAT|O_EXCL. If that went
1082                  * NT_STATUS_OK, we *know* we created this file.
1083                  */
1084                 *file_created = NT_STATUS_IS_OK(status);
1085
1086                 return status;
1087         }
1088
1089         /*
1090          * Now it gets tricky. We have O_CREAT, but not O_EXCL.
1091          * To know absolutely if we created the file or not,
1092          * we can never call O_CREAT without O_EXCL. So if
1093          * we think the file existed, try without O_CREAT|O_EXCL.
1094          * If we think the file didn't exist, try with
1095          * O_CREAT|O_EXCL.
1096          *
1097          * The big problem here is dangling symlinks. Opening
1098          * without O_NOFOLLOW means both bad symlink
1099          * and missing path return -1, ENOENT from open(). As POSIX
1100          * is pathname based it's not possible to tell
1101          * the difference between these two cases in a
1102          * non-racy way, so change to try only two attempts before
1103          * giving up.
1104          *
1105          * We don't have this problem for the O_NOFOLLOW
1106          * case as it just returns NT_STATUS_OBJECT_PATH_NOT_FOUND
1107          * mapped from the ELOOP POSIX error.
1108          */
1109
1110         if (file_existed) {
1111                 curr_flags = flags & ~(O_CREAT);
1112                 retry_status = NT_STATUS_OBJECT_NAME_NOT_FOUND;
1113         } else {
1114                 curr_flags = flags | O_EXCL;
1115                 retry_status = NT_STATUS_OBJECT_NAME_COLLISION;
1116         }
1117
1118         status = fd_open(conn, fsp, curr_flags, mode);
1119         if (NT_STATUS_IS_OK(status)) {
1120                 *file_created = !file_existed;
1121                 return NT_STATUS_OK;
1122         }
1123         if (NT_STATUS_EQUAL(status, retry_status)) {
1124
1125                 file_existed = !file_existed;
1126
1127                 DBG_DEBUG("File %s %s. Retry.\n",
1128                           fsp_str_dbg(fsp),
1129                           file_existed ? "existed" : "did not exist");
1130
1131                 if (file_existed) {
1132                         curr_flags = flags & ~(O_CREAT);
1133                 } else {
1134                         curr_flags = flags | O_EXCL;
1135                 }
1136
1137                 status = fd_open(conn, fsp, curr_flags, mode);
1138         }
1139
1140         *file_created = (NT_STATUS_IS_OK(status) && !file_existed);
1141         return status;
1142 }
1143
1144 /****************************************************************************
1145  Open a file.
1146 ****************************************************************************/
1147
1148 static NTSTATUS open_file(files_struct *fsp,
1149                           connection_struct *conn,
1150                           struct smb_request *req,
1151                           const char *parent_dir,
1152                           int flags,
1153                           mode_t unx_mode,
1154                           uint32_t access_mask, /* client requested access mask. */
1155                           uint32_t open_access_mask, /* what we're actually using in the open. */
1156                           bool *p_file_created)
1157 {
1158         struct smb_filename *smb_fname = fsp->fsp_name;
1159         NTSTATUS status = NT_STATUS_OK;
1160         int accmode = (flags & O_ACCMODE);
1161         int local_flags = flags;
1162         bool file_existed = VALID_STAT(fsp->fsp_name->st);
1163
1164         fsp->fh->fd = -1;
1165         errno = EPERM;
1166
1167         /* Check permissions */
1168
1169         /*
1170          * This code was changed after seeing a client open request
1171          * containing the open mode of (DENY_WRITE/read-only) with
1172          * the 'create if not exist' bit set. The previous code
1173          * would fail to open the file read only on a read-only share
1174          * as it was checking the flags parameter  directly against O_RDONLY,
1175          * this was failing as the flags parameter was set to O_RDONLY|O_CREAT.
1176          * JRA.
1177          */
1178
1179         if (!CAN_WRITE(conn)) {
1180                 /* It's a read-only share - fail if we wanted to write. */
1181                 if(accmode != O_RDONLY || (flags & O_TRUNC) || (flags & O_APPEND)) {
1182                         DEBUG(3,("Permission denied opening %s\n",
1183                                  smb_fname_str_dbg(smb_fname)));
1184                         return NT_STATUS_ACCESS_DENIED;
1185                 }
1186                 if (flags & O_CREAT) {
1187                         /* We don't want to write - but we must make sure that
1188                            O_CREAT doesn't create the file if we have write
1189                            access into the directory.
1190                         */
1191                         flags &= ~(O_CREAT|O_EXCL);
1192                         local_flags &= ~(O_CREAT|O_EXCL);
1193                 }
1194         }
1195
1196         /*
1197          * This little piece of insanity is inspired by the
1198          * fact that an NT client can open a file for O_RDONLY,
1199          * but set the create disposition to FILE_EXISTS_TRUNCATE.
1200          * If the client *can* write to the file, then it expects to
1201          * truncate the file, even though it is opening for readonly.
1202          * Quicken uses this stupid trick in backup file creation...
1203          * Thanks *greatly* to "David W. Chapman Jr." <dwcjr@inethouston.net>
1204          * for helping track this one down. It didn't bite us in 2.0.x
1205          * as we always opened files read-write in that release. JRA.
1206          */
1207
1208         if ((accmode == O_RDONLY) && ((flags & O_TRUNC) == O_TRUNC)) {
1209                 DEBUG(10,("open_file: truncate requested on read-only open "
1210                           "for file %s\n", smb_fname_str_dbg(smb_fname)));
1211                 local_flags = (flags & ~O_ACCMODE)|O_RDWR;
1212         }
1213
1214         if ((open_access_mask & (FILE_READ_DATA|FILE_WRITE_DATA|
1215                                  FILE_APPEND_DATA|FILE_EXECUTE|
1216                                  WRITE_DAC_ACCESS|WRITE_OWNER_ACCESS|
1217                                  READ_CONTROL_ACCESS))||
1218             (!file_existed && (local_flags & O_CREAT)) ||
1219             ((local_flags & O_TRUNC) == O_TRUNC) ) {
1220                 const char *wild;
1221                 int ret;
1222
1223 #if defined(O_NONBLOCK) && defined(S_ISFIFO)
1224                 /*
1225                  * We would block on opening a FIFO with no one else on the
1226                  * other end. Do what we used to do and add O_NONBLOCK to the
1227                  * open flags. JRA.
1228                  */
1229
1230                 if (file_existed && S_ISFIFO(smb_fname->st.st_ex_mode)) {
1231                         local_flags &= ~O_TRUNC; /* Can't truncate a FIFO. */
1232                         local_flags |= O_NONBLOCK;
1233                 }
1234 #endif
1235
1236                 /* Don't create files with Microsoft wildcard characters. */
1237                 if (fsp->base_fsp) {
1238                         /*
1239                          * wildcard characters are allowed in stream names
1240                          * only test the basefilename
1241                          */
1242                         wild = fsp->base_fsp->fsp_name->base_name;
1243                 } else {
1244                         wild = smb_fname->base_name;
1245                 }
1246                 if ((local_flags & O_CREAT) && !file_existed &&
1247                     !(fsp->posix_flags & FSP_POSIX_FLAGS_PATHNAMES) &&
1248                     ms_has_wild(wild))  {
1249                         return NT_STATUS_OBJECT_NAME_INVALID;
1250                 }
1251
1252                 /* Can we access this file ? */
1253                 if (!fsp->base_fsp) {
1254                         /* Only do this check on non-stream open. */
1255                         if (file_existed) {
1256                                 status = smbd_check_access_rights(conn,
1257                                                 smb_fname,
1258                                                 false,
1259                                                 access_mask);
1260
1261                                 if (!NT_STATUS_IS_OK(status)) {
1262                                         DEBUG(10, ("open_file: "
1263                                                    "smbd_check_access_rights "
1264                                                    "on file %s returned %s\n",
1265                                                    smb_fname_str_dbg(smb_fname),
1266                                                    nt_errstr(status)));
1267                                 }
1268
1269                                 if (!NT_STATUS_IS_OK(status) &&
1270                                     !NT_STATUS_EQUAL(status,
1271                                         NT_STATUS_OBJECT_NAME_NOT_FOUND))
1272                                 {
1273                                         return status;
1274                                 }
1275
1276                                 if (NT_STATUS_EQUAL(status,
1277                                         NT_STATUS_OBJECT_NAME_NOT_FOUND))
1278                                 {
1279                                         DEBUG(10, ("open_file: "
1280                                                 "file %s vanished since we "
1281                                                 "checked for existence.\n",
1282                                                 smb_fname_str_dbg(smb_fname)));
1283                                         file_existed = false;
1284                                         SET_STAT_INVALID(fsp->fsp_name->st);
1285                                 }
1286                         }
1287
1288                         if (!file_existed) {
1289                                 if (!(local_flags & O_CREAT)) {
1290                                         /* File didn't exist and no O_CREAT. */
1291                                         return NT_STATUS_OBJECT_NAME_NOT_FOUND;
1292                                 }
1293
1294                                 status = check_parent_access(conn,
1295                                                              smb_fname,
1296                                                              SEC_DIR_ADD_FILE);
1297                                 if (!NT_STATUS_IS_OK(status)) {
1298                                         DEBUG(10, ("open_file: "
1299                                                    "check_parent_access on "
1300                                                    "file %s returned %s\n",
1301                                                    smb_fname_str_dbg(smb_fname),
1302                                                    nt_errstr(status) ));
1303                                         return status;
1304                                 }
1305                         }
1306                 }
1307
1308                 /*
1309                  * Actually do the open - if O_TRUNC is needed handle it
1310                  * below under the share mode lock.
1311                  */
1312                 status = fd_open_atomic(conn, fsp, local_flags & ~O_TRUNC,
1313                                 unx_mode, p_file_created);
1314                 if (!NT_STATUS_IS_OK(status)) {
1315                         DEBUG(3,("Error opening file %s (%s) (local_flags=%d) "
1316                                  "(flags=%d)\n", smb_fname_str_dbg(smb_fname),
1317                                  nt_errstr(status),local_flags,flags));
1318                         return status;
1319                 }
1320
1321                 if (local_flags & O_NONBLOCK) {
1322                         /*
1323                          * GPFS can return ETIMEDOUT for pread on
1324                          * nonblocking file descriptors when files
1325                          * migrated to tape need to be recalled. I
1326                          * could imagine this happens elsewhere
1327                          * too. With blocking file descriptors this
1328                          * does not happen.
1329                          */
1330                         ret = vfs_set_blocking(fsp, true);
1331                         if (ret == -1) {
1332                                 status = map_nt_error_from_unix(errno);
1333                                 DBG_WARNING("Could not set fd to blocking: "
1334                                             "%s\n", strerror(errno));
1335                                 fd_close(fsp);
1336                                 return status;
1337                         }
1338                 }
1339
1340                 ret = SMB_VFS_FSTAT(fsp, &smb_fname->st);
1341                 if (ret == -1) {
1342                         /* If we have an fd, this stat should succeed. */
1343                         DEBUG(0,("Error doing fstat on open file %s "
1344                                 "(%s)\n",
1345                                 smb_fname_str_dbg(smb_fname),
1346                                 strerror(errno) ));
1347                         status = map_nt_error_from_unix(errno);
1348                         fd_close(fsp);
1349                         return status;
1350                 }
1351
1352                 if (*p_file_created) {
1353                         /* We created this file. */
1354
1355                         bool need_re_stat = false;
1356                         /* Do all inheritance work after we've
1357                            done a successful fstat call and filled
1358                            in the stat struct in fsp->fsp_name. */
1359
1360                         /* Inherit the ACL if required */
1361                         if (lp_inherit_permissions(SNUM(conn))) {
1362                                 inherit_access_posix_acl(conn, parent_dir,
1363                                                          smb_fname,
1364                                                          unx_mode);
1365                                 need_re_stat = true;
1366                         }
1367
1368                         /* Change the owner if required. */
1369                         if (lp_inherit_owner(SNUM(conn)) != INHERIT_OWNER_NO) {
1370                                 change_file_owner_to_parent(conn, parent_dir,
1371                                                             fsp);
1372                                 need_re_stat = true;
1373                         }
1374
1375                         if (need_re_stat) {
1376                                 ret = SMB_VFS_FSTAT(fsp, &smb_fname->st);
1377                                 /* If we have an fd, this stat should succeed. */
1378                                 if (ret == -1) {
1379                                         DEBUG(0,("Error doing fstat on open file %s "
1380                                                  "(%s)\n",
1381                                                  smb_fname_str_dbg(smb_fname),
1382                                                  strerror(errno) ));
1383                                 }
1384                         }
1385
1386                         notify_fname(conn, NOTIFY_ACTION_ADDED,
1387                                      FILE_NOTIFY_CHANGE_FILE_NAME,
1388                                      smb_fname->base_name);
1389                 }
1390         } else {
1391                 fsp->fh->fd = -1; /* What we used to call a stat open. */
1392                 if (!file_existed) {
1393                         /* File must exist for a stat open. */
1394                         return NT_STATUS_OBJECT_NAME_NOT_FOUND;
1395                 }
1396
1397                 status = smbd_check_access_rights(conn,
1398                                 smb_fname,
1399                                 false,
1400                                 access_mask);
1401
1402                 if (NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND) &&
1403                                 (fsp->posix_flags & FSP_POSIX_FLAGS_OPEN) &&
1404                                 S_ISLNK(smb_fname->st.st_ex_mode)) {
1405                         /* This is a POSIX stat open for delete
1406                          * or rename on a symlink that points
1407                          * nowhere. Allow. */
1408                         DEBUG(10,("open_file: allowing POSIX "
1409                                   "open on bad symlink %s\n",
1410                                   smb_fname_str_dbg(smb_fname)));
1411                         status = NT_STATUS_OK;
1412                 }
1413
1414                 if (!NT_STATUS_IS_OK(status)) {
1415                         DEBUG(10,("open_file: "
1416                                 "smbd_check_access_rights on file "
1417                                 "%s returned %s\n",
1418                                 smb_fname_str_dbg(smb_fname),
1419                                 nt_errstr(status) ));
1420                         return status;
1421                 }
1422         }
1423
1424         /*
1425          * POSIX allows read-only opens of directories. We don't
1426          * want to do this (we use a different code path for this)
1427          * so catch a directory open and return an EISDIR. JRA.
1428          */
1429
1430         if(S_ISDIR(smb_fname->st.st_ex_mode)) {
1431                 fd_close(fsp);
1432                 errno = EISDIR;
1433                 return NT_STATUS_FILE_IS_A_DIRECTORY;
1434         }
1435
1436         fsp->file_id = vfs_file_id_from_sbuf(conn, &smb_fname->st);
1437         fsp->vuid = req ? req->vuid : UID_FIELD_INVALID;
1438         fsp->file_pid = req ? req->smbpid : 0;
1439         fsp->can_lock = True;
1440         fsp->can_read = ((access_mask & FILE_READ_DATA) != 0);
1441         fsp->can_write =
1442                 CAN_WRITE(conn) &&
1443                 ((access_mask & (FILE_WRITE_DATA | FILE_APPEND_DATA)) != 0);
1444         fsp->print_file = NULL;
1445         fsp->modified = False;
1446         fsp->sent_oplock_break = NO_BREAK_SENT;
1447         fsp->is_directory = False;
1448         if (conn->aio_write_behind_list &&
1449             is_in_path(smb_fname->base_name, conn->aio_write_behind_list,
1450                        conn->case_sensitive)) {
1451                 fsp->aio_write_behind = True;
1452         }
1453
1454         DEBUG(2,("%s opened file %s read=%s write=%s (numopen=%d)\n",
1455                  conn->session_info->unix_info->unix_name,
1456                  smb_fname_str_dbg(smb_fname),
1457                  BOOLSTR(fsp->can_read), BOOLSTR(fsp->can_write),
1458                  conn->num_files_open));
1459
1460         errno = 0;
1461         return NT_STATUS_OK;
1462 }
1463
1464 static bool mask_conflict(
1465         uint32_t new_access,
1466         uint32_t existing_access,
1467         uint32_t access_mask,
1468         uint32_t new_sharemode,
1469         uint32_t existing_sharemode,
1470         uint32_t sharemode_mask)
1471 {
1472         bool want_access = (new_access & access_mask);
1473         bool allow_existing = (existing_sharemode & sharemode_mask);
1474         bool have_access = (existing_access & access_mask);
1475         bool allow_new = (new_sharemode & sharemode_mask);
1476
1477         if (want_access && !allow_existing) {
1478                 DBG_DEBUG("Access request 0x%"PRIx32"/0x%"PRIx32" conflicts "
1479                           "with existing sharemode 0x%"PRIx32"/0x%"PRIx32"\n",
1480                           new_access,
1481                           access_mask,
1482                           existing_sharemode,
1483                           sharemode_mask);
1484                 return true;
1485         }
1486         if (have_access && !allow_new) {
1487                 DBG_DEBUG("Sharemode request 0x%"PRIx32"/0x%"PRIx32" conflicts "
1488                           "with existing access 0x%"PRIx32"/0x%"PRIx32"\n",
1489                           new_sharemode,
1490                           sharemode_mask,
1491                           existing_access,
1492                           access_mask);
1493                 return true;
1494         }
1495         return false;
1496 }
1497
1498 /****************************************************************************
1499  Check if we can open a file with a share mode.
1500  Returns True if conflict, False if not.
1501 ****************************************************************************/
1502
1503 static bool share_conflict(uint32_t e_access_mask,
1504                            uint32_t e_share_access,
1505                            uint32_t access_mask,
1506                            uint32_t share_access)
1507 {
1508         const uint32_t conflicting_access =
1509                 FILE_WRITE_DATA|
1510                 FILE_APPEND_DATA|
1511                 FILE_READ_DATA|
1512                 FILE_EXECUTE|
1513                 DELETE_ACCESS;
1514         bool conflict;
1515
1516         DBG_DEBUG("existing access_mask = 0x%"PRIx32", "
1517                   "existing share access = 0x%"PRIx32", "
1518                   "access_mask = 0x%"PRIx32", "
1519                   "share_access = 0x%"PRIx32"\n",
1520                   e_access_mask,
1521                   e_share_access,
1522                   access_mask,
1523                   share_access);
1524
1525         if ((e_access_mask & conflicting_access) == 0) {
1526                 DBG_DEBUG("No conflict due to "
1527                           "existing access_mask = 0x%"PRIx32"\n",
1528                           e_access_mask);
1529                 return false;
1530         }
1531         if ((access_mask & conflicting_access) == 0) {
1532                 DBG_DEBUG("No conflict due to access_mask = 0x%"PRIx32"\n",
1533                           access_mask);
1534                 return false;
1535         }
1536
1537         conflict = mask_conflict(
1538                 access_mask, e_access_mask, FILE_WRITE_DATA | FILE_APPEND_DATA,
1539                 share_access, e_share_access, FILE_SHARE_WRITE);
1540         conflict |= mask_conflict(
1541                 access_mask, e_access_mask, FILE_READ_DATA | FILE_EXECUTE,
1542                 share_access, e_share_access, FILE_SHARE_READ);
1543         conflict |= mask_conflict(
1544                 access_mask, e_access_mask, DELETE_ACCESS,
1545                 share_access, e_share_access, FILE_SHARE_DELETE);
1546
1547         DBG_DEBUG("conflict=%s\n", conflict ? "true" : "false");
1548         return conflict;
1549 }
1550
1551 #if defined(DEVELOPER)
1552
1553 struct validate_my_share_entries_state {
1554         struct smbd_server_connection *sconn;
1555         struct file_id fid;
1556         struct server_id self;
1557 };
1558
1559 static bool validate_my_share_entries_fn(
1560         struct share_mode_entry *e,
1561         bool *modified,
1562         void *private_data)
1563 {
1564         struct validate_my_share_entries_state *state = private_data;
1565         files_struct *fsp;
1566
1567         if (!server_id_equal(&state->self, &e->pid)) {
1568                 return false;
1569         }
1570
1571         if (e->op_mid == 0) {
1572                 /* INTERNAL_OPEN_ONLY */
1573                 return false;
1574         }
1575
1576         fsp = file_find_dif(state->sconn, state->fid, e->share_file_id);
1577         if (!fsp) {
1578                 DBG_ERR("PANIC : %s\n",
1579                         share_mode_str(talloc_tos(), 0, &state->fid, e));
1580                 smb_panic("validate_my_share_entries: Cannot match a "
1581                           "share entry with an open file\n");
1582         }
1583
1584         if (((uint16_t)fsp->oplock_type) != e->op_type) {
1585                 goto panic;
1586         }
1587
1588         return false;
1589
1590  panic:
1591         {
1592                 char *str;
1593                 DBG_ERR("validate_my_share_entries: PANIC : %s\n",
1594                         share_mode_str(talloc_tos(), 0, &state->fid, e));
1595                 str = talloc_asprintf(talloc_tos(),
1596                         "validate_my_share_entries: "
1597                         "file %s, oplock_type = 0x%x, op_type = 0x%x\n",
1598                          fsp->fsp_name->base_name,
1599                          (unsigned int)fsp->oplock_type,
1600                          (unsigned int)e->op_type);
1601                 smb_panic(str);
1602         }
1603
1604         return false;
1605 }
1606 #endif
1607
1608 bool is_stat_open(uint32_t access_mask)
1609 {
1610         const uint32_t stat_open_bits =
1611                 (SYNCHRONIZE_ACCESS|
1612                  FILE_READ_ATTRIBUTES|
1613                  FILE_WRITE_ATTRIBUTES);
1614
1615         return (((access_mask &  stat_open_bits) != 0) &&
1616                 ((access_mask & ~stat_open_bits) == 0));
1617 }
1618
1619 struct has_delete_on_close_state {
1620         bool ret;
1621 };
1622
1623 static bool has_delete_on_close_fn(
1624         struct share_mode_entry *e,
1625         bool *modified,
1626         void *private_data)
1627 {
1628         struct has_delete_on_close_state *state = private_data;
1629         state->ret = !share_entry_stale_pid(e);
1630         return state->ret;
1631 }
1632
1633 static bool has_delete_on_close(struct share_mode_lock *lck,
1634                                 uint32_t name_hash)
1635 {
1636         struct has_delete_on_close_state state = { .ret = false };
1637         bool ok;
1638
1639         if (!is_delete_on_close_set(lck, name_hash)) {
1640                 return false;
1641         }
1642
1643         ok= share_mode_forall_entries(lck, has_delete_on_close_fn, &state);
1644         if (!ok) {
1645                 DBG_DEBUG("share_mode_forall_entries failed\n");
1646                 return false;
1647         }
1648         return state.ret;
1649 }
1650
1651 static void share_mode_flags_get(
1652         uint16_t flags,
1653         uint32_t *access_mask,
1654         uint32_t *share_mode,
1655         uint32_t *lease_type)
1656 {
1657         if (access_mask != NULL) {
1658                 *access_mask =
1659                         ((flags & SHARE_MODE_ACCESS_READ) ?
1660                          FILE_READ_DATA : 0) |
1661                         ((flags & SHARE_MODE_ACCESS_WRITE) ?
1662                          FILE_WRITE_DATA : 0) |
1663                         ((flags & SHARE_MODE_ACCESS_DELETE) ?
1664                          DELETE_ACCESS : 0);
1665         }
1666         if (share_mode != NULL) {
1667                 *share_mode =
1668                         ((flags & SHARE_MODE_SHARE_READ) ?
1669                          FILE_SHARE_READ : 0) |
1670                         ((flags & SHARE_MODE_SHARE_WRITE) ?
1671                          FILE_SHARE_WRITE : 0) |
1672                         ((flags & SHARE_MODE_SHARE_DELETE) ?
1673                          FILE_SHARE_DELETE : 0);
1674         }
1675         if (lease_type != NULL) {
1676                 *lease_type =
1677                         ((flags & SHARE_MODE_LEASE_READ) ?
1678                          SMB2_LEASE_READ : 0) |
1679                         ((flags & SHARE_MODE_LEASE_WRITE) ?
1680                          SMB2_LEASE_WRITE : 0) |
1681                         ((flags & SHARE_MODE_LEASE_HANDLE) ?
1682                          SMB2_LEASE_HANDLE : 0);
1683         }
1684 }
1685
1686 static uint16_t share_mode_flags_set(
1687         uint16_t flags,
1688         uint32_t access_mask,
1689         uint32_t share_mode,
1690         uint32_t lease_type)
1691 {
1692         if (access_mask != UINT32_MAX) {
1693                 flags &= ~(SHARE_MODE_ACCESS_READ|
1694                            SHARE_MODE_ACCESS_WRITE|
1695                            SHARE_MODE_ACCESS_DELETE);
1696                 flags |= (access_mask & (FILE_READ_DATA | FILE_EXECUTE)) ?
1697                         SHARE_MODE_ACCESS_READ : 0;
1698                 flags |= (access_mask & (FILE_WRITE_DATA | FILE_APPEND_DATA)) ?
1699                         SHARE_MODE_ACCESS_WRITE : 0;
1700                 flags |= (access_mask & (DELETE_ACCESS)) ?
1701                         SHARE_MODE_ACCESS_DELETE : 0;
1702         }
1703         if (share_mode != UINT32_MAX) {
1704                 flags &= ~(SHARE_MODE_SHARE_READ|
1705                            SHARE_MODE_SHARE_WRITE|
1706                            SHARE_MODE_SHARE_DELETE);
1707                 flags |= (share_mode & FILE_SHARE_READ) ?
1708                         SHARE_MODE_SHARE_READ : 0;
1709                 flags |= (share_mode & FILE_SHARE_WRITE) ?
1710                         SHARE_MODE_SHARE_WRITE : 0;
1711                 flags |= (share_mode & FILE_SHARE_DELETE) ?
1712                         SHARE_MODE_SHARE_DELETE : 0;
1713         }
1714         if (lease_type != UINT32_MAX) {
1715                 flags &= ~(SHARE_MODE_LEASE_READ|
1716                            SHARE_MODE_LEASE_WRITE|
1717                            SHARE_MODE_LEASE_HANDLE);
1718                 flags |= (lease_type & SMB2_LEASE_READ) ?
1719                         SHARE_MODE_LEASE_READ : 0;
1720                 flags |= (lease_type & SMB2_LEASE_WRITE) ?
1721                         SHARE_MODE_LEASE_WRITE : 0;
1722                 flags |= (lease_type & SMB2_LEASE_HANDLE) ?
1723                         SHARE_MODE_LEASE_HANDLE : 0;
1724         }
1725
1726         return flags;
1727 }
1728
1729 static uint16_t share_mode_flags_restrict(
1730         uint16_t flags,
1731         uint32_t access_mask,
1732         uint32_t share_mode,
1733         uint32_t lease_type)
1734 {
1735         uint32_t existing_access_mask, existing_share_mode;
1736         uint32_t existing_lease_type;
1737         uint16_t ret;
1738
1739         share_mode_flags_get(
1740                 flags,
1741                 &existing_access_mask,
1742                 &existing_share_mode,
1743                 &existing_lease_type);
1744
1745         existing_access_mask |= access_mask;
1746         existing_share_mode &= share_mode;
1747         existing_lease_type |= lease_type;
1748
1749         ret = share_mode_flags_set(
1750                 flags,
1751                 existing_access_mask,
1752                 existing_share_mode,
1753                 existing_lease_type);
1754         return ret;
1755 }
1756
1757 /****************************************************************************
1758  Deal with share modes
1759  Invariant: Share mode must be locked on entry and exit.
1760  Returns -1 on error, or number of share modes on success (may be zero).
1761 ****************************************************************************/
1762
1763 struct open_mode_check_state {
1764         struct file_id fid;
1765         uint32_t access_mask;
1766         uint32_t share_access;
1767         uint32_t lease_type;
1768 };
1769
1770 static bool open_mode_check_fn(
1771         struct share_mode_entry *e,
1772         bool *modified,
1773         void *private_data)
1774 {
1775         struct open_mode_check_state *state = private_data;
1776         bool disconnected, stale;
1777         uint32_t access_mask, share_access, lease_type;
1778
1779         disconnected = server_id_is_disconnected(&e->pid);
1780         if (disconnected) {
1781                 return false;
1782         }
1783
1784         access_mask = state->access_mask | e->access_mask;
1785         share_access = state->share_access & e->share_access;
1786         lease_type = state->lease_type | get_lease_type(e, state->fid);
1787
1788         if ((access_mask == state->access_mask) &&
1789             (share_access == state->share_access) &&
1790             (lease_type == state->lease_type)) {
1791                 return false;
1792         }
1793
1794         stale = share_entry_stale_pid(e);
1795         if (stale) {
1796                 return false;
1797         }
1798
1799         state->access_mask = access_mask;
1800         state->share_access = share_access;
1801         state->lease_type = lease_type;
1802
1803         return false;
1804 }
1805
1806 static NTSTATUS open_mode_check(connection_struct *conn,
1807                                 struct share_mode_lock *lck,
1808                                 uint32_t access_mask,
1809                                 uint32_t share_access)
1810 {
1811         struct share_mode_data *d = lck->data;
1812         struct open_mode_check_state state;
1813         uint16_t new_flags;
1814         bool ok, conflict;
1815
1816         if (is_stat_open(access_mask)) {
1817                 /* Stat open that doesn't trigger oplock breaks or share mode
1818                  * checks... ! JRA. */
1819                 return NT_STATUS_OK;
1820         }
1821
1822         /*
1823          * Check if the share modes will give us access.
1824          */
1825
1826 #if defined(DEVELOPER)
1827         {
1828                 struct validate_my_share_entries_state validate_state = {
1829                         .sconn = conn->sconn,
1830                         .fid = d->id,
1831                         .self = messaging_server_id(conn->sconn->msg_ctx),
1832                 };
1833                 ok = share_mode_forall_entries(
1834                         lck, validate_my_share_entries_fn, &validate_state);
1835                 SMB_ASSERT(ok);
1836         }
1837 #endif
1838
1839         if (d->num_share_modes == 0) {
1840                 return NT_STATUS_OK;
1841         }
1842
1843         share_mode_flags_get(
1844                 d->flags, &state.access_mask, &state.share_access, NULL);
1845
1846         conflict = share_conflict(
1847                 state.access_mask,
1848                 state.share_access,
1849                 access_mask,
1850                 share_access);
1851         if (!conflict) {
1852                 DBG_DEBUG("No conflict due to share_mode_flags access\n");
1853                 return NT_STATUS_OK;
1854         }
1855
1856         state = (struct open_mode_check_state) {
1857                 .fid = d->id,
1858                 .share_access = (FILE_SHARE_READ|
1859                                  FILE_SHARE_WRITE|
1860                                  FILE_SHARE_DELETE),
1861         };
1862
1863         /*
1864          * Walk the share mode array to recalculate d->flags
1865          */
1866
1867         ok = share_mode_forall_entries(lck, open_mode_check_fn, &state);
1868         if (!ok) {
1869                 DBG_DEBUG("share_mode_forall_entries failed\n");
1870                 return NT_STATUS_INTERNAL_ERROR;
1871         }
1872
1873         new_flags = share_mode_flags_set(
1874                 0, state.access_mask, state.share_access, state.lease_type);
1875         if (new_flags == d->flags) {
1876                 /*
1877                  * We only end up here if we had a sharing violation
1878                  * from d->flags and have recalculated it.
1879                  */
1880                 return NT_STATUS_SHARING_VIOLATION;
1881         }
1882
1883         d->flags = new_flags;
1884         d->modified = true;
1885
1886         conflict = share_conflict(
1887                 state.access_mask,
1888                 state.share_access,
1889                 access_mask,
1890                 share_access);
1891         if (!conflict) {
1892                 DBG_DEBUG("No conflict due to share_mode_flags access\n");
1893                 return NT_STATUS_OK;
1894         }
1895
1896         return NT_STATUS_SHARING_VIOLATION;
1897 }
1898
1899 /*
1900  * Send a break message to the oplock holder and delay the open for
1901  * our client.
1902  */
1903
1904 NTSTATUS send_break_message(struct messaging_context *msg_ctx,
1905                             const struct file_id *id,
1906                             const struct share_mode_entry *exclusive,
1907                             uint16_t break_to)
1908 {
1909         struct oplock_break_message msg = {
1910                 .id = *id,
1911                 .share_file_id = exclusive->share_file_id,
1912                 .break_to = break_to,
1913         };
1914         enum ndr_err_code ndr_err;
1915         DATA_BLOB blob;
1916         NTSTATUS status;
1917
1918         if (DEBUGLVL(10)) {
1919                 struct server_id_buf buf;
1920                 DBG_DEBUG("Sending break message to %s\n",
1921                           server_id_str_buf(exclusive->pid, &buf));
1922                 NDR_PRINT_DEBUG(oplock_break_message, &msg);
1923         }
1924
1925         ndr_err = ndr_push_struct_blob(
1926                 &blob,
1927                 talloc_tos(),
1928                 &msg,
1929                 (ndr_push_flags_fn_t)ndr_push_oplock_break_message);
1930         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1931                 DBG_WARNING("ndr_push_oplock_break_message failed: %s\n",
1932                             ndr_errstr(ndr_err));
1933                 return ndr_map_error2ntstatus(ndr_err);
1934         }
1935
1936         status = messaging_send(
1937                 msg_ctx, exclusive->pid, MSG_SMB_BREAK_REQUEST, &blob);
1938         TALLOC_FREE(blob.data);
1939         if (!NT_STATUS_IS_OK(status)) {
1940                 DEBUG(3, ("Could not send oplock break message: %s\n",
1941                           nt_errstr(status)));
1942         }
1943
1944         return status;
1945 }
1946
1947 struct validate_oplock_types_state {
1948         bool valid;
1949         bool batch;
1950         bool ex_or_batch;
1951         bool level2;
1952         bool no_oplock;
1953         uint32_t num_non_stat_opens;
1954 };
1955
1956 static bool validate_oplock_types_fn(
1957         struct share_mode_entry *e,
1958         bool *modified,
1959         void *private_data)
1960 {
1961         struct validate_oplock_types_state *state = private_data;
1962
1963         if (e->op_mid == 0) {
1964                 /* INTERNAL_OPEN_ONLY */
1965                 return false;
1966         }
1967
1968         if (e->op_type == NO_OPLOCK && is_stat_open(e->access_mask)) {
1969                 /*
1970                  * We ignore stat opens in the table - they always
1971                  * have NO_OPLOCK and never get or cause breaks. JRA.
1972                  */
1973                 return false;
1974         }
1975
1976         state->num_non_stat_opens += 1;
1977
1978         if (BATCH_OPLOCK_TYPE(e->op_type)) {
1979                 /* batch - can only be one. */
1980                 if (share_entry_stale_pid(e)) {
1981                         DBG_DEBUG("Found stale batch oplock\n");
1982                         return false;
1983                 }
1984                 if (state->ex_or_batch ||
1985                     state->batch ||
1986                     state->level2 ||
1987                     state->no_oplock) {
1988                         DBG_ERR("Bad batch oplock entry\n");
1989                         state->valid = false;
1990                         return true;
1991                 }
1992                 state->batch = true;
1993         }
1994
1995         if (EXCLUSIVE_OPLOCK_TYPE(e->op_type)) {
1996                 if (share_entry_stale_pid(e)) {
1997                         DBG_DEBUG("Found stale duplicate oplock\n");
1998                         return false;
1999                 }
2000                 /* Exclusive or batch - can only be one. */
2001                 if (state->ex_or_batch ||
2002                     state->level2 ||
2003                     state->no_oplock) {
2004                         DBG_ERR("Bad exclusive or batch oplock entry\n");
2005                         state->valid = false;
2006                         return true;
2007                 }
2008                 state->ex_or_batch = true;
2009         }
2010
2011         if (LEVEL_II_OPLOCK_TYPE(e->op_type)) {
2012                 if (state->batch || state->ex_or_batch) {
2013                         if (share_entry_stale_pid(e)) {
2014                                 DBG_DEBUG("Found stale LevelII oplock\n");
2015                                 return false;
2016                         }
2017                         DBG_DEBUG("Bad levelII oplock entry\n");
2018                         state->valid = false;
2019                         return true;
2020                 }
2021                 state->level2 = true;
2022         }
2023
2024         if (e->op_type == NO_OPLOCK) {
2025                 if (state->batch || state->ex_or_batch) {
2026                         if (share_entry_stale_pid(e)) {
2027                                 DBG_DEBUG("Found stale NO_OPLOCK entry\n");
2028                                 return false;
2029                         }
2030                         DBG_ERR("Bad no oplock entry\n");
2031                         state->valid = false;
2032                         return true;
2033                 }
2034                 state->no_oplock = true;
2035         }
2036
2037         return false;
2038 }
2039
2040 /*
2041  * Do internal consistency checks on the share mode for a file.
2042  */
2043
2044 static bool validate_oplock_types(struct share_mode_lock *lck)
2045 {
2046         struct validate_oplock_types_state state = { .valid = true };
2047         bool ok;
2048
2049         ok = share_mode_forall_entries(lck, validate_oplock_types_fn, &state);
2050         if (!ok) {
2051                 DBG_DEBUG("share_mode_forall_entries failed\n");
2052                 return false;
2053         }
2054         if (!state.valid) {
2055                 DBG_DEBUG("Got invalid oplock configuration\n");
2056                 return false;
2057         }
2058
2059         if ((state.batch || state.ex_or_batch) &&
2060             (state.num_non_stat_opens != 1)) {
2061                 DBG_WARNING("got batch (%d) or ex (%d) non-exclusively "
2062                             "(%"PRIu32")\n",
2063                             (int)state.batch,
2064                             (int)state.ex_or_batch,
2065                             state.num_non_stat_opens);
2066                 return false;
2067         }
2068
2069         return true;
2070 }
2071
2072 static bool is_same_lease(const files_struct *fsp,
2073                           const struct share_mode_entry *e,
2074                           const struct smb2_lease *lease)
2075 {
2076         if (e->op_type != LEASE_OPLOCK) {
2077                 return false;
2078         }
2079         if (lease == NULL) {
2080                 return false;
2081         }
2082
2083         return smb2_lease_equal(fsp_client_guid(fsp),
2084                                 &lease->lease_key,
2085                                 &e->client_guid,
2086                                 &e->lease_key);
2087 }
2088
2089 static bool file_has_brlocks(files_struct *fsp)
2090 {
2091         struct byte_range_lock *br_lck;
2092
2093         br_lck = brl_get_locks_readonly(fsp);
2094         if (!br_lck)
2095                 return false;
2096
2097         return (brl_num_locks(br_lck) > 0);
2098 }
2099
2100 struct fsp_lease *find_fsp_lease(struct files_struct *new_fsp,
2101                                  const struct smb2_lease_key *key,
2102                                  uint32_t current_state,
2103                                  uint16_t lease_version,
2104                                  uint16_t lease_epoch)
2105 {
2106         struct files_struct *fsp;
2107
2108         /*
2109          * TODO: Measure how expensive this loop is with thousands of open
2110          * handles...
2111          */
2112
2113         for (fsp = file_find_di_first(new_fsp->conn->sconn, new_fsp->file_id);
2114              fsp != NULL;
2115              fsp = file_find_di_next(fsp)) {
2116
2117                 if (fsp == new_fsp) {
2118                         continue;
2119                 }
2120                 if (fsp->oplock_type != LEASE_OPLOCK) {
2121                         continue;
2122                 }
2123                 if (smb2_lease_key_equal(&fsp->lease->lease.lease_key, key)) {
2124                         fsp->lease->ref_count += 1;
2125                         return fsp->lease;
2126                 }
2127         }
2128
2129         /* Not found - must be leased in another smbd. */
2130         new_fsp->lease = talloc_zero(new_fsp->conn->sconn, struct fsp_lease);
2131         if (new_fsp->lease == NULL) {
2132                 return NULL;
2133         }
2134         new_fsp->lease->ref_count = 1;
2135         new_fsp->lease->sconn = new_fsp->conn->sconn;
2136         new_fsp->lease->lease.lease_key = *key;
2137         new_fsp->lease->lease.lease_state = current_state;
2138         /*
2139          * We internally treat all leases as V2 and update
2140          * the epoch, but when sending breaks it matters if
2141          * the requesting lease was v1 or v2.
2142          */
2143         new_fsp->lease->lease.lease_version = lease_version;
2144         new_fsp->lease->lease.lease_epoch = lease_epoch;
2145         return new_fsp->lease;
2146 }
2147
2148 static NTSTATUS try_lease_upgrade(struct files_struct *fsp,
2149                                   struct share_mode_lock *lck,
2150                                   const struct GUID *client_guid,
2151                                   const struct smb2_lease *lease,
2152                                   uint32_t granted)
2153 {
2154         bool do_upgrade;
2155         uint32_t current_state, breaking_to_requested, breaking_to_required;
2156         bool breaking;
2157         uint16_t lease_version, epoch;
2158         uint32_t existing, requested;
2159         NTSTATUS status;
2160
2161         status = leases_db_get(
2162                 client_guid,
2163                 &lease->lease_key,
2164                 &fsp->file_id,
2165                 &current_state,
2166                 &breaking,
2167                 &breaking_to_requested,
2168                 &breaking_to_required,
2169                 &lease_version,
2170                 &epoch);
2171         if (!NT_STATUS_IS_OK(status)) {
2172                 return status;
2173         }
2174
2175         fsp->lease = find_fsp_lease(
2176                 fsp,
2177                 &lease->lease_key,
2178                 current_state,
2179                 lease_version,
2180                 epoch);
2181         if (fsp->lease == NULL) {
2182                 DEBUG(1, ("Did not find existing lease for file %s\n",
2183                           fsp_str_dbg(fsp)));
2184                 return NT_STATUS_NO_MEMORY;
2185         }
2186
2187         /*
2188          * Upgrade only if the requested lease is a strict upgrade.
2189          */
2190         existing = current_state;
2191         requested = lease->lease_state;
2192
2193         /*
2194          * Tricky: This test makes sure that "requested" is a
2195          * strict bitwise superset of "existing".
2196          */
2197         do_upgrade = ((existing & requested) == existing);
2198
2199         /*
2200          * Upgrade only if there's a change.
2201          */
2202         do_upgrade &= (granted != existing);
2203
2204         /*
2205          * Upgrade only if other leases don't prevent what was asked
2206          * for.
2207          */
2208         do_upgrade &= (granted == requested);
2209
2210         /*
2211          * only upgrade if we are not in breaking state
2212          */
2213         do_upgrade &= !breaking;
2214
2215         DEBUG(10, ("existing=%"PRIu32", requested=%"PRIu32", "
2216                    "granted=%"PRIu32", do_upgrade=%d\n",
2217                    existing, requested, granted, (int)do_upgrade));
2218
2219         if (do_upgrade) {
2220                 NTSTATUS set_status;
2221
2222                 current_state = granted;
2223                 epoch += 1;
2224
2225                 set_status = leases_db_set(
2226                         client_guid,
2227                         &lease->lease_key,
2228                         current_state,
2229                         breaking,
2230                         breaking_to_requested,
2231                         breaking_to_required,
2232                         lease_version,
2233                         epoch);
2234
2235                 if (!NT_STATUS_IS_OK(set_status)) {
2236                         DBG_DEBUG("leases_db_set failed: %s\n",
2237                                   nt_errstr(set_status));
2238                         return set_status;
2239                 }
2240         }
2241
2242         fsp_lease_update(fsp);
2243
2244         return NT_STATUS_OK;
2245 }
2246
2247 static NTSTATUS grant_new_fsp_lease(struct files_struct *fsp,
2248                                     struct share_mode_lock *lck,
2249                                     const struct GUID *client_guid,
2250                                     const struct smb2_lease *lease,
2251                                     uint32_t granted)
2252 {
2253         struct share_mode_data *d = lck->data;
2254         NTSTATUS status;
2255
2256         fsp->lease = talloc_zero(fsp->conn->sconn, struct fsp_lease);
2257         if (fsp->lease == NULL) {
2258                 return NT_STATUS_INSUFFICIENT_RESOURCES;
2259         }
2260         fsp->lease->ref_count = 1;
2261         fsp->lease->sconn = fsp->conn->sconn;
2262         fsp->lease->lease.lease_version = lease->lease_version;
2263         fsp->lease->lease.lease_key = lease->lease_key;
2264         fsp->lease->lease.lease_state = granted;
2265         fsp->lease->lease.lease_epoch = lease->lease_epoch + 1;
2266
2267         status = leases_db_add(client_guid,
2268                                &lease->lease_key,
2269                                &fsp->file_id,
2270                                fsp->lease->lease.lease_state,
2271                                fsp->lease->lease.lease_version,
2272                                fsp->lease->lease.lease_epoch,
2273                                fsp->conn->connectpath,
2274                                fsp->fsp_name->base_name,
2275                                fsp->fsp_name->stream_name);
2276         if (!NT_STATUS_IS_OK(status)) {
2277                 DEBUG(10, ("%s: leases_db_add failed: %s\n", __func__,
2278                            nt_errstr(status)));
2279                 TALLOC_FREE(fsp->lease);
2280                 return NT_STATUS_INSUFFICIENT_RESOURCES;
2281         }
2282
2283         d->modified = true;
2284
2285         return NT_STATUS_OK;
2286 }
2287
2288 static NTSTATUS grant_fsp_lease(struct files_struct *fsp,
2289                                 struct share_mode_lock *lck,
2290                                 const struct smb2_lease *lease,
2291                                 uint32_t granted)
2292 {
2293         const struct GUID *client_guid = fsp_client_guid(fsp);
2294         NTSTATUS status;
2295
2296         status = try_lease_upgrade(fsp, lck, client_guid, lease, granted);
2297
2298         if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_FOUND)) {
2299                 status = grant_new_fsp_lease(
2300                         fsp, lck, client_guid, lease, granted);
2301         }
2302
2303         return status;
2304 }
2305
2306 static int map_lease_type_to_oplock(uint32_t lease_type)
2307 {
2308         int result = NO_OPLOCK;
2309
2310         switch (lease_type) {
2311         case SMB2_LEASE_READ|SMB2_LEASE_WRITE|SMB2_LEASE_HANDLE:
2312                 result = BATCH_OPLOCK|EXCLUSIVE_OPLOCK;
2313                 break;
2314         case SMB2_LEASE_READ|SMB2_LEASE_WRITE:
2315                 result = EXCLUSIVE_OPLOCK;
2316                 break;
2317         case SMB2_LEASE_READ|SMB2_LEASE_HANDLE:
2318         case SMB2_LEASE_READ:
2319                 result = LEVEL_II_OPLOCK;
2320                 break;
2321         }
2322
2323         return result;
2324 }
2325
2326 struct delay_for_oplock_state {
2327         struct files_struct *fsp;
2328         const struct smb2_lease *lease;
2329         bool will_overwrite;
2330         uint32_t delay_mask;
2331         bool first_open_attempt;
2332         bool got_handle_lease;
2333         bool got_oplock;
2334         bool have_other_lease;
2335         bool delay;
2336 };
2337
2338 static bool delay_for_oplock_fn(
2339         struct share_mode_entry *e,
2340         bool *modified,
2341         void *private_data)
2342 {
2343         struct delay_for_oplock_state *state = private_data;
2344         struct files_struct *fsp = state->fsp;
2345         const struct smb2_lease *lease = state->lease;
2346         bool e_is_lease = (e->op_type == LEASE_OPLOCK);
2347         uint32_t e_lease_type = get_lease_type(e, fsp->file_id);
2348         uint32_t break_to;
2349         bool lease_is_breaking = false;
2350
2351         if (e_is_lease) {
2352                 NTSTATUS status;
2353
2354                 if (lease != NULL) {
2355                         bool our_lease = is_same_lease(fsp, e, lease);
2356                         if (our_lease) {
2357                                 DBG_DEBUG("Ignoring our own lease\n");
2358                                 return false;
2359                         }
2360                 }
2361
2362                 status = leases_db_get(
2363                         &e->client_guid,
2364                         &e->lease_key,
2365                         &fsp->file_id,
2366                         NULL, /* current_state */
2367                         &lease_is_breaking,
2368                         NULL, /* breaking_to_requested */
2369                         NULL, /* breaking_to_required */
2370                         NULL, /* lease_version */
2371                         NULL); /* epoch */
2372                 SMB_ASSERT(NT_STATUS_IS_OK(status));
2373         }
2374
2375         if (!state->got_handle_lease &&
2376             ((e_lease_type & SMB2_LEASE_HANDLE) != 0) &&
2377             !share_entry_stale_pid(e)) {
2378                 state->got_handle_lease = true;
2379         }
2380
2381         if (!state->got_oplock &&
2382             (e->op_type != LEASE_OPLOCK) &&
2383             !share_entry_stale_pid(e)) {
2384                 state->got_oplock = true;
2385         }
2386
2387         if (!state->have_other_lease &&
2388             !is_same_lease(fsp, e, lease) &&
2389             !share_entry_stale_pid(e)) {
2390                 state->have_other_lease = true;
2391         }
2392
2393         break_to = e_lease_type & ~state->delay_mask;
2394
2395         if (state->will_overwrite) {
2396                 break_to &= ~(SMB2_LEASE_HANDLE|SMB2_LEASE_READ);
2397         }
2398
2399         DBG_DEBUG("e_lease_type %u, will_overwrite: %u\n",
2400                   (unsigned)e_lease_type,
2401                   (unsigned)state->will_overwrite);
2402
2403         if ((e_lease_type & ~break_to) == 0) {
2404                 if (lease_is_breaking) {
2405                         state->delay = true;
2406                 }
2407                 return false;
2408         }
2409
2410         if (share_entry_stale_pid(e)) {
2411                 return false;
2412         }
2413
2414         if (state->will_overwrite) {
2415                 /*
2416                  * If we break anyway break to NONE directly.
2417                  * Otherwise vfs_set_filelen() will trigger the
2418                  * break.
2419                  */
2420                 break_to &= ~(SMB2_LEASE_READ|SMB2_LEASE_WRITE);
2421         }
2422
2423         if (!e_is_lease) {
2424                 /*
2425                  * Oplocks only support breaking to R or NONE.
2426                  */
2427                 break_to &= ~(SMB2_LEASE_HANDLE|SMB2_LEASE_WRITE);
2428         }
2429
2430         DBG_DEBUG("breaking from %d to %d\n",
2431                   (int)e_lease_type,
2432                   (int)break_to);
2433         send_break_message(
2434                 fsp->conn->sconn->msg_ctx, &fsp->file_id, e, break_to);
2435         if (e_lease_type & state->delay_mask) {
2436                 state->delay = true;
2437         }
2438         if (lease_is_breaking && !state->first_open_attempt) {
2439                 state->delay = true;
2440         }
2441
2442         return false;
2443 };
2444
2445 static NTSTATUS delay_for_oplock(files_struct *fsp,
2446                                  int oplock_request,
2447                                  const struct smb2_lease *lease,
2448                                  struct share_mode_lock *lck,
2449                                  bool have_sharing_violation,
2450                                  uint32_t create_disposition,
2451                                  bool first_open_attempt)
2452 {
2453         struct delay_for_oplock_state state = {
2454                 .fsp = fsp,
2455                 .lease = lease,
2456                 .first_open_attempt = first_open_attempt,
2457         };
2458         uint32_t granted;
2459         NTSTATUS status;
2460         bool ok;
2461
2462         if (is_stat_open(fsp->access_mask)) {
2463                 goto grant;
2464         }
2465
2466         state.delay_mask = have_sharing_violation ?
2467                 SMB2_LEASE_HANDLE : SMB2_LEASE_WRITE;
2468
2469         switch (create_disposition) {
2470         case FILE_SUPERSEDE:
2471         case FILE_OVERWRITE:
2472         case FILE_OVERWRITE_IF:
2473                 state.will_overwrite = true;
2474                 break;
2475         default:
2476                 state.will_overwrite = false;
2477                 break;
2478         }
2479
2480         ok = share_mode_forall_entries(lck, delay_for_oplock_fn, &state);
2481         if (!ok) {
2482                 return NT_STATUS_INTERNAL_ERROR;
2483         }
2484
2485         if (state.delay) {
2486                 return NT_STATUS_RETRY;
2487         }
2488
2489 grant:
2490         if (have_sharing_violation) {
2491                 return NT_STATUS_SHARING_VIOLATION;
2492         }
2493
2494         if (oplock_request == LEASE_OPLOCK) {
2495                 if (lease == NULL) {
2496                         /*
2497                          * The SMB2 layer should have checked this
2498                          */
2499                         return NT_STATUS_INTERNAL_ERROR;
2500                 }
2501
2502                 granted = lease->lease_state;
2503
2504                 if (lp_kernel_oplocks(SNUM(fsp->conn))) {
2505                         DEBUG(10, ("No lease granted because kernel oplocks are enabled\n"));
2506                         granted = SMB2_LEASE_NONE;
2507                 }
2508                 if ((granted & (SMB2_LEASE_READ|SMB2_LEASE_WRITE)) == 0) {
2509                         DEBUG(10, ("No read or write lease requested\n"));
2510                         granted = SMB2_LEASE_NONE;
2511                 }
2512                 if (granted == SMB2_LEASE_WRITE) {
2513                         DEBUG(10, ("pure write lease requested\n"));
2514                         granted = SMB2_LEASE_NONE;
2515                 }
2516                 if (granted == (SMB2_LEASE_WRITE|SMB2_LEASE_HANDLE)) {
2517                         DEBUG(10, ("write and handle lease requested\n"));
2518                         granted = SMB2_LEASE_NONE;
2519                 }
2520         } else {
2521                 granted = map_oplock_to_lease_type(
2522                         oplock_request & ~SAMBA_PRIVATE_OPLOCK_MASK);
2523         }
2524
2525         if (lp_locking(fsp->conn->params) && file_has_brlocks(fsp)) {
2526                 DBG_DEBUG("file %s has byte range locks\n",
2527                           fsp_str_dbg(fsp));
2528                 granted &= ~SMB2_LEASE_READ;
2529         }
2530
2531         if (state.have_other_lease) {
2532                 /*
2533                  * Can grant only one writer
2534                  */
2535                 granted &= ~SMB2_LEASE_WRITE;
2536         }
2537
2538         if ((granted & SMB2_LEASE_READ) && !(granted & SMB2_LEASE_WRITE)) {
2539                 bool allow_level2 =
2540                         (global_client_caps & CAP_LEVEL_II_OPLOCKS) &&
2541                         lp_level2_oplocks(SNUM(fsp->conn));
2542
2543                 if (!allow_level2) {
2544                         granted = SMB2_LEASE_NONE;
2545                 }
2546         }
2547
2548         if (oplock_request == LEASE_OPLOCK) {
2549                 if (state.got_oplock) {
2550                         granted &= ~SMB2_LEASE_HANDLE;
2551                 }
2552
2553                 fsp->oplock_type = LEASE_OPLOCK;
2554
2555                 status = grant_fsp_lease(fsp, lck, lease, granted);
2556                 if (!NT_STATUS_IS_OK(status)) {
2557                         return status;
2558
2559                 }
2560
2561                 DBG_DEBUG("lease_state=%d\n", fsp->lease->lease.lease_state);
2562         } else {
2563                 if (state.got_handle_lease) {
2564                         granted = SMB2_LEASE_NONE;
2565                 }
2566
2567                 fsp->oplock_type = map_lease_type_to_oplock(granted);
2568
2569                 status = set_file_oplock(fsp);
2570                 if (!NT_STATUS_IS_OK(status)) {
2571                         /*
2572                          * Could not get the kernel oplock
2573                          */
2574                         fsp->oplock_type = NO_OPLOCK;
2575                 }
2576         }
2577
2578         if (granted & SMB2_LEASE_READ) {
2579                 lck->data->flags |= SHARE_MODE_LEASE_READ;
2580         }
2581
2582         DBG_DEBUG("oplock type 0x%x on file %s\n",
2583                   fsp->oplock_type, fsp_str_dbg(fsp));
2584
2585         return NT_STATUS_OK;
2586 }
2587
2588 static NTSTATUS handle_share_mode_lease(
2589         files_struct *fsp,
2590         struct share_mode_lock *lck,
2591         uint32_t create_disposition,
2592         uint32_t access_mask,
2593         uint32_t share_access,
2594         int oplock_request,
2595         const struct smb2_lease *lease,
2596         bool first_open_attempt)
2597 {
2598         bool sharing_violation = false;
2599         NTSTATUS status;
2600
2601         status = open_mode_check(
2602                 fsp->conn, lck, access_mask, share_access);
2603         if (NT_STATUS_EQUAL(status, NT_STATUS_SHARING_VIOLATION)) {
2604                 sharing_violation = true;
2605                 status = NT_STATUS_OK; /* handled later */
2606         }
2607
2608         if (!NT_STATUS_IS_OK(status)) {
2609                 return status;
2610         }
2611
2612         if (oplock_request == INTERNAL_OPEN_ONLY) {
2613                 if (sharing_violation) {
2614                         DBG_DEBUG("Sharing violation for internal open\n");
2615                         return NT_STATUS_SHARING_VIOLATION;
2616                 }
2617
2618                 /*
2619                  * Internal opens never do oplocks or leases. We don't
2620                  * need to go through delay_for_oplock().
2621                  */
2622                 fsp->oplock_type = NO_OPLOCK;
2623
2624                 return NT_STATUS_OK;
2625         }
2626
2627         status = delay_for_oplock(
2628                 fsp,
2629                 oplock_request,
2630                 lease,
2631                 lck,
2632                 sharing_violation,
2633                 create_disposition,
2634                 first_open_attempt);
2635         if (!NT_STATUS_IS_OK(status)) {
2636                 return status;
2637         }
2638
2639         return NT_STATUS_OK;
2640 }
2641
2642 static bool request_timed_out(struct smb_request *req, struct timeval timeout)
2643 {
2644         struct timeval now, end_time;
2645         GetTimeOfDay(&now);
2646         end_time = timeval_sum(&req->request_time, &timeout);
2647         return (timeval_compare(&end_time, &now) < 0);
2648 }
2649
2650 struct defer_open_state {
2651         struct smbXsrv_connection *xconn;
2652         uint64_t mid;
2653 };
2654
2655 static void defer_open_done(struct tevent_req *req);
2656
2657 /**
2658  * Defer an open and watch a locking.tdb record
2659  *
2660  * This defers an open that gets rescheduled once the locking.tdb record watch
2661  * is triggered by a change to the record.
2662  *
2663  * It is used to defer opens that triggered an oplock break and for the SMB1
2664  * sharing violation delay.
2665  **/
2666 static void defer_open(struct share_mode_lock *lck,
2667                        struct timeval timeout,
2668                        struct smb_request *req,
2669                        bool delayed_for_oplocks,
2670                        struct file_id id)
2671 {
2672         struct deferred_open_record *open_rec = NULL;
2673         struct timeval abs_timeout;
2674         struct defer_open_state *watch_state;
2675         struct tevent_req *watch_req;
2676         struct timeval_buf tvbuf1, tvbuf2;
2677         struct file_id_buf fbuf;
2678         bool ok;
2679
2680         abs_timeout = timeval_sum(&req->request_time, &timeout);
2681
2682         DBG_DEBUG("request time [%s] timeout [%s] mid [%" PRIu64 "] "
2683                   "delayed_for_oplocks [%s] file_id [%s]\n",
2684                   timeval_str_buf(&req->request_time, false, true, &tvbuf1),
2685                   timeval_str_buf(&abs_timeout, false, true, &tvbuf2),
2686                   req->mid,
2687                   delayed_for_oplocks ? "yes" : "no",
2688                   file_id_str_buf(id, &fbuf));
2689
2690         open_rec = talloc_zero(NULL, struct deferred_open_record);
2691         if (open_rec == NULL) {
2692                 TALLOC_FREE(lck);
2693                 exit_server("talloc failed");
2694         }
2695
2696         watch_state = talloc(open_rec, struct defer_open_state);
2697         if (watch_state == NULL) {
2698                 exit_server("talloc failed");
2699         }
2700         watch_state->xconn = req->xconn;
2701         watch_state->mid = req->mid;
2702
2703         DBG_DEBUG("defering mid %" PRIu64 "\n", req->mid);
2704
2705         watch_req = share_mode_watch_send(
2706                 watch_state,
2707                 req->sconn->ev_ctx,
2708                 lck->data->id,
2709                 (struct server_id){0});
2710         if (watch_req == NULL) {
2711                 exit_server("Could not watch share mode record");
2712         }
2713         tevent_req_set_callback(watch_req, defer_open_done, watch_state);
2714
2715         ok = tevent_req_set_endtime(watch_req, req->sconn->ev_ctx, abs_timeout);
2716         if (!ok) {
2717                 exit_server("tevent_req_set_endtime failed");
2718         }
2719
2720         ok = push_deferred_open_message_smb(req, timeout, id, open_rec);
2721         if (!ok) {
2722                 TALLOC_FREE(lck);
2723                 exit_server("push_deferred_open_message_smb failed");
2724         }
2725 }
2726
2727 static void defer_open_done(struct tevent_req *req)
2728 {
2729         struct defer_open_state *state = tevent_req_callback_data(
2730                 req, struct defer_open_state);
2731         NTSTATUS status;
2732         bool ret;
2733
2734         status = share_mode_watch_recv(req, NULL, NULL);
2735         TALLOC_FREE(req);
2736         if (!NT_STATUS_IS_OK(status)) {
2737                 DEBUG(5, ("dbwrap_watched_watch_recv returned %s\n",
2738                           nt_errstr(status)));
2739                 /*
2740                  * Even if it failed, retry anyway. TODO: We need a way to
2741                  * tell a re-scheduled open about that error.
2742                  */
2743         }
2744
2745         DEBUG(10, ("scheduling mid %llu\n", (unsigned long long)state->mid));
2746
2747         ret = schedule_deferred_open_message_smb(state->xconn, state->mid);
2748         SMB_ASSERT(ret);
2749         TALLOC_FREE(state);
2750 }
2751
2752 /**
2753  * Actually attempt the kernel oplock polling open.
2754  */
2755
2756 static void poll_open_fn(struct tevent_context *ev,
2757                          struct tevent_timer *te,
2758                          struct timeval current_time,
2759                          void *private_data)
2760 {
2761         struct deferred_open_record *open_rec = talloc_get_type_abort(
2762                 private_data, struct deferred_open_record);
2763         bool ok;
2764
2765         TALLOC_FREE(open_rec->watch_req);
2766
2767         ok = schedule_deferred_open_message_smb(
2768                 open_rec->xconn, open_rec->mid);
2769         if (!ok) {
2770                 exit_server("schedule_deferred_open_message_smb failed");
2771         }
2772         DBG_DEBUG("timer fired. Retrying open !\n");
2773 }
2774
2775 static void poll_open_done(struct tevent_req *subreq);
2776
2777 /**
2778  * Reschedule an open for 1 second from now, if not timed out.
2779  **/
2780 static bool setup_poll_open(
2781         struct smb_request *req,
2782         struct share_mode_lock *lck,
2783         struct file_id id,
2784         struct timeval max_timeout,
2785         struct timeval interval)
2786 {
2787         bool ok;
2788         struct deferred_open_record *open_rec = NULL;
2789         struct timeval endtime, next_interval;
2790         struct file_id_buf ftmp;
2791
2792         if (request_timed_out(req, max_timeout)) {
2793                 return false;
2794         }
2795
2796         open_rec = talloc_zero(NULL, struct deferred_open_record);
2797         if (open_rec == NULL) {
2798                 DBG_WARNING("talloc failed\n");
2799                 return false;
2800         }
2801         open_rec->xconn = req->xconn;
2802         open_rec->mid = req->mid;
2803
2804         /*
2805          * Make sure open_rec->te does not come later than the
2806          * request's maximum endtime.
2807          */
2808
2809         endtime = timeval_sum(&req->request_time, &max_timeout);
2810         next_interval = timeval_current_ofs(interval.tv_sec, interval.tv_usec);
2811         next_interval = timeval_min(&endtime, &next_interval);
2812
2813         open_rec->te = tevent_add_timer(
2814                 req->sconn->ev_ctx,
2815                 open_rec,
2816                 next_interval,
2817                 poll_open_fn,
2818                 open_rec);
2819         if (open_rec->te == NULL) {
2820                 DBG_WARNING("tevent_add_timer failed\n");
2821                 TALLOC_FREE(open_rec);
2822                 return false;
2823         }
2824
2825         if (lck != NULL) {
2826                 open_rec->watch_req = share_mode_watch_send(
2827                         open_rec,
2828                         req->sconn->ev_ctx,
2829                         lck->data->id,
2830                         (struct server_id) {0});
2831                 if (open_rec->watch_req == NULL) {
2832                         DBG_WARNING("share_mode_watch_send failed\n");
2833                         TALLOC_FREE(open_rec);
2834                         return false;
2835                 }
2836                 tevent_req_set_callback(
2837                         open_rec->watch_req, poll_open_done, open_rec);
2838         }
2839
2840         ok = push_deferred_open_message_smb(req, max_timeout, id, open_rec);
2841         if (!ok) {
2842                 DBG_WARNING("push_deferred_open_message_smb failed\n");
2843                 TALLOC_FREE(open_rec);
2844                 return false;
2845         }
2846
2847         DBG_DEBUG("poll request time [%s] mid [%" PRIu64 "] file_id [%s]\n",
2848                   timeval_string(talloc_tos(), &req->request_time, false),
2849                   req->mid,
2850                   file_id_str_buf(id, &ftmp));
2851
2852         return true;
2853 }
2854
2855 static void poll_open_done(struct tevent_req *subreq)
2856 {
2857         struct deferred_open_record *open_rec = tevent_req_callback_data(
2858                 subreq, struct deferred_open_record);
2859         NTSTATUS status;
2860         bool ok;
2861
2862         status = share_mode_watch_recv(subreq, NULL, NULL);
2863         TALLOC_FREE(subreq);
2864         DBG_DEBUG("dbwrap_watched_watch_recv returned %s\n",
2865                   nt_errstr(status));
2866
2867         ok = schedule_deferred_open_message_smb(
2868                 open_rec->xconn, open_rec->mid);
2869         if (!ok) {
2870                 exit_server("schedule_deferred_open_message_smb failed");
2871         }
2872 }
2873
2874 bool defer_smb1_sharing_violation(struct smb_request *req)
2875 {
2876         bool ok;
2877         int timeout_usecs;
2878
2879         if (!lp_defer_sharing_violations()) {
2880                 return false;
2881         }
2882
2883         /*
2884          * Try every 200msec up to (by default) one second. To be
2885          * precise, according to behaviour note <247> in [MS-CIFS],
2886          * the server tries 5 times. But up to one second should be
2887          * close enough.
2888          */
2889
2890         timeout_usecs = lp_parm_int(
2891                 SNUM(req->conn),
2892                 "smbd",
2893                 "sharedelay",
2894                 SHARING_VIOLATION_USEC_WAIT);
2895
2896         ok = setup_poll_open(
2897                 req,
2898                 NULL,
2899                 (struct file_id) {0},
2900                 (struct timeval) { .tv_usec = timeout_usecs },
2901                 (struct timeval) { .tv_usec = 200000 });
2902         return ok;
2903 }
2904
2905 /****************************************************************************
2906  On overwrite open ensure that the attributes match.
2907 ****************************************************************************/
2908
2909 static bool open_match_attributes(connection_struct *conn,
2910                                   uint32_t old_dos_attr,
2911                                   uint32_t new_dos_attr,
2912                                   mode_t new_unx_mode,
2913                                   mode_t *returned_unx_mode)
2914 {
2915         uint32_t noarch_old_dos_attr, noarch_new_dos_attr;
2916
2917         noarch_old_dos_attr = (old_dos_attr & ~FILE_ATTRIBUTE_ARCHIVE);
2918         noarch_new_dos_attr = (new_dos_attr & ~FILE_ATTRIBUTE_ARCHIVE);
2919
2920         if((noarch_old_dos_attr == 0 && noarch_new_dos_attr != 0) ||
2921            (noarch_old_dos_attr != 0 && ((noarch_old_dos_attr & noarch_new_dos_attr) == noarch_old_dos_attr))) {
2922                 *returned_unx_mode = new_unx_mode;
2923         } else {
2924                 *returned_unx_mode = (mode_t)0;
2925         }
2926
2927         DEBUG(10,("open_match_attributes: old_dos_attr = 0x%x, "
2928                   "new_dos_attr = 0x%x "
2929                   "returned_unx_mode = 0%o\n",
2930                   (unsigned int)old_dos_attr,
2931                   (unsigned int)new_dos_attr,
2932                   (unsigned int)*returned_unx_mode ));
2933
2934         /* If we're mapping SYSTEM and HIDDEN ensure they match. */
2935         if (lp_map_system(SNUM(conn)) || lp_store_dos_attributes(SNUM(conn))) {
2936                 if ((old_dos_attr & FILE_ATTRIBUTE_SYSTEM) &&
2937                     !(new_dos_attr & FILE_ATTRIBUTE_SYSTEM)) {
2938                         return False;
2939                 }
2940         }
2941         if (lp_map_hidden(SNUM(conn)) || lp_store_dos_attributes(SNUM(conn))) {
2942                 if ((old_dos_attr & FILE_ATTRIBUTE_HIDDEN) &&
2943                     !(new_dos_attr & FILE_ATTRIBUTE_HIDDEN)) {
2944                         return False;
2945                 }
2946         }
2947         return True;
2948 }
2949
2950 static void schedule_defer_open(struct share_mode_lock *lck,
2951                                 struct file_id id,
2952                                 struct smb_request *req)
2953 {
2954         /* This is a relative time, added to the absolute
2955            request_time value to get the absolute timeout time.
2956            Note that if this is the second or greater time we enter
2957            this codepath for this particular request mid then
2958            request_time is left as the absolute time of the *first*
2959            time this request mid was processed. This is what allows
2960            the request to eventually time out. */
2961
2962         struct timeval timeout;
2963
2964         /* Normally the smbd we asked should respond within
2965          * OPLOCK_BREAK_TIMEOUT seconds regardless of whether
2966          * the client did, give twice the timeout as a safety
2967          * measure here in case the other smbd is stuck
2968          * somewhere else. */
2969
2970         timeout = timeval_set(OPLOCK_BREAK_TIMEOUT*2, 0);
2971
2972         if (request_timed_out(req, timeout)) {
2973                 return;
2974         }
2975
2976         defer_open(lck, timeout, req, true, id);
2977 }
2978
2979 /****************************************************************************
2980  Reschedule an open call that went asynchronous.
2981 ****************************************************************************/
2982
2983 static void schedule_async_open_timer(struct tevent_context *ev,
2984                                       struct tevent_timer *te,
2985                                       struct timeval current_time,
2986                                       void *private_data)
2987 {
2988         exit_server("async open timeout");
2989 }
2990
2991 static void schedule_async_open(struct smb_request *req)
2992 {
2993         struct deferred_open_record *open_rec = NULL;
2994         struct timeval timeout = timeval_set(20, 0);
2995         bool ok;
2996
2997         if (request_timed_out(req, timeout)) {
2998                 return;
2999         }
3000
3001         open_rec = talloc_zero(NULL, struct deferred_open_record);
3002         if (open_rec == NULL) {
3003                 exit_server("deferred_open_record_create failed");
3004         }
3005         open_rec->async_open = true;
3006
3007         ok = push_deferred_open_message_smb(
3008                 req, timeout, (struct file_id){0}, open_rec);
3009         if (!ok) {
3010                 exit_server("push_deferred_open_message_smb failed");
3011         }
3012
3013         open_rec->te = tevent_add_timer(req->sconn->ev_ctx,
3014                                         req,
3015                                         timeval_current_ofs(20, 0),
3016                                         schedule_async_open_timer,
3017                                         open_rec);
3018         if (open_rec->te == NULL) {
3019                 exit_server("tevent_add_timer failed");
3020         }
3021 }
3022
3023 /****************************************************************************
3024  Work out what access_mask to use from what the client sent us.
3025 ****************************************************************************/
3026
3027 static NTSTATUS smbd_calculate_maximum_allowed_access(
3028         connection_struct *conn,
3029         const struct smb_filename *smb_fname,
3030         bool use_privs,
3031         uint32_t *p_access_mask)
3032 {
3033         struct security_descriptor *sd;
3034         uint32_t access_granted;
3035         NTSTATUS status;
3036
3037         if (!use_privs && (get_current_uid(conn) == (uid_t)0)) {
3038                 *p_access_mask |= FILE_GENERIC_ALL;
3039                 return NT_STATUS_OK;
3040         }
3041
3042         status = SMB_VFS_GET_NT_ACL(conn, smb_fname,
3043                                     (SECINFO_OWNER |
3044                                      SECINFO_GROUP |
3045                                      SECINFO_DACL),
3046                                     talloc_tos(), &sd);
3047
3048         if (NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
3049                 /*
3050                  * File did not exist
3051                  */
3052                 *p_access_mask = FILE_GENERIC_ALL;
3053                 return NT_STATUS_OK;
3054         }
3055         if (!NT_STATUS_IS_OK(status)) {
3056                 DEBUG(10,("Could not get acl on file %s: %s\n",
3057                           smb_fname_str_dbg(smb_fname),
3058                           nt_errstr(status)));
3059                 return NT_STATUS_ACCESS_DENIED;
3060         }
3061
3062         /*
3063          * If we can access the path to this file, by
3064          * default we have FILE_READ_ATTRIBUTES from the
3065          * containing directory. See the section:
3066          * "Algorithm to Check Access to an Existing File"
3067          * in MS-FSA.pdf.
3068          *
3069          * se_file_access_check()
3070          * also takes care of owner WRITE_DAC and READ_CONTROL.
3071          */
3072         status = se_file_access_check(sd,
3073                                  get_current_nttok(conn),
3074                                  use_privs,
3075                                  (*p_access_mask & ~FILE_READ_ATTRIBUTES),
3076                                  &access_granted);
3077
3078         TALLOC_FREE(sd);
3079
3080         if (!NT_STATUS_IS_OK(status)) {
3081                 DEBUG(10, ("Access denied on file %s: "
3082                            "when calculating maximum access\n",
3083                            smb_fname_str_dbg(smb_fname)));
3084                 return NT_STATUS_ACCESS_DENIED;
3085         }
3086         *p_access_mask = (access_granted | FILE_READ_ATTRIBUTES);
3087
3088         if (!(access_granted & DELETE_ACCESS)) {
3089                 if (can_delete_file_in_directory(conn, smb_fname)) {
3090                         *p_access_mask |= DELETE_ACCESS;
3091                 }
3092         }
3093
3094         return NT_STATUS_OK;
3095 }
3096
3097 NTSTATUS smbd_calculate_access_mask(connection_struct *conn,
3098                                     const struct smb_filename *smb_fname,
3099                                     bool use_privs,
3100                                     uint32_t access_mask,
3101                                     uint32_t *access_mask_out)
3102 {
3103         NTSTATUS status;
3104         uint32_t orig_access_mask = access_mask;
3105         uint32_t rejected_share_access;
3106
3107         if (access_mask & SEC_MASK_INVALID) {
3108                 DBG_DEBUG("access_mask [%8x] contains invalid bits\n",
3109                           access_mask);
3110                 return NT_STATUS_ACCESS_DENIED;
3111         }
3112
3113         /*
3114          * Convert GENERIC bits to specific bits.
3115          */
3116
3117         se_map_generic(&access_mask, &file_generic_mapping);
3118
3119         /* Calculate MAXIMUM_ALLOWED_ACCESS if requested. */
3120         if (access_mask & MAXIMUM_ALLOWED_ACCESS) {
3121
3122                 status = smbd_calculate_maximum_allowed_access(
3123                         conn, smb_fname, use_privs, &access_mask);
3124
3125                 if (!NT_STATUS_IS_OK(status)) {
3126                         return status;
3127                 }
3128
3129                 access_mask &= conn->share_access;
3130         }
3131
3132         rejected_share_access = access_mask & ~(conn->share_access);
3133
3134         if (rejected_share_access) {
3135                 DEBUG(10, ("smbd_calculate_access_mask: Access denied on "
3136                         "file %s: rejected by share access mask[0x%08X] "
3137                         "orig[0x%08X] mapped[0x%08X] reject[0x%08X]\n",
3138                         smb_fname_str_dbg(smb_fname),
3139                         conn->share_access,
3140                         orig_access_mask, access_mask,
3141                         rejected_share_access));
3142                 return NT_STATUS_ACCESS_DENIED;
3143         }
3144
3145         *access_mask_out = access_mask;
3146         return NT_STATUS_OK;
3147 }
3148
3149 /****************************************************************************
3150  Remove the deferred open entry under lock.
3151 ****************************************************************************/
3152
3153 /****************************************************************************
3154  Return true if this is a state pointer to an asynchronous create.
3155 ****************************************************************************/
3156
3157 bool is_deferred_open_async(const struct deferred_open_record *rec)
3158 {
3159         return rec->async_open;
3160 }
3161
3162 static bool clear_ads(uint32_t create_disposition)
3163 {
3164         bool ret = false;
3165
3166         switch (create_disposition) {
3167         case FILE_SUPERSEDE:
3168         case FILE_OVERWRITE_IF:
3169         case FILE_OVERWRITE:
3170                 ret = true;
3171                 break;
3172         default:
3173                 break;
3174         }
3175         return ret;
3176 }
3177
3178 static int disposition_to_open_flags(uint32_t create_disposition)
3179 {
3180         int ret = 0;
3181
3182         /*
3183          * Currently we're using FILE_SUPERSEDE as the same as
3184          * FILE_OVERWRITE_IF but they really are
3185          * different. FILE_SUPERSEDE deletes an existing file
3186          * (requiring delete access) then recreates it.
3187          */
3188
3189         switch (create_disposition) {
3190         case FILE_SUPERSEDE:
3191         case FILE_OVERWRITE_IF:
3192                 /*
3193                  * If file exists replace/overwrite. If file doesn't
3194                  * exist create.
3195                  */
3196                 ret = O_CREAT|O_TRUNC;
3197                 break;
3198
3199         case FILE_OPEN:
3200                 /*
3201                  * If file exists open. If file doesn't exist error.
3202                  */
3203                 ret = 0;
3204                 break;
3205
3206         case FILE_OVERWRITE:
3207                 /*
3208                  * If file exists overwrite. If file doesn't exist
3209                  * error.
3210                  */
3211                 ret = O_TRUNC;
3212                 break;
3213
3214         case FILE_CREATE:
3215                 /*
3216                  * If file exists error. If file doesn't exist create.
3217                  */
3218                 ret = O_CREAT|O_EXCL;
3219                 break;
3220
3221         case FILE_OPEN_IF:
3222                 /*
3223                  * If file exists open. If file doesn't exist create.
3224                  */
3225                 ret = O_CREAT;
3226                 break;
3227         }
3228         return ret;
3229 }
3230
3231 static int calculate_open_access_flags(uint32_t access_mask,
3232                                        uint32_t private_flags)
3233 {
3234         bool need_write, need_read;
3235
3236         /*
3237          * Note that we ignore the append flag as append does not
3238          * mean the same thing under DOS and Unix.
3239          */
3240
3241         need_write = (access_mask & (FILE_WRITE_DATA | FILE_APPEND_DATA));
3242         if (!need_write) {
3243                 return O_RDONLY;
3244         }
3245
3246         /* DENY_DOS opens are always underlying read-write on the
3247            file handle, no matter what the requested access mask
3248            says. */
3249
3250         need_read =
3251                 ((private_flags & NTCREATEX_OPTIONS_PRIVATE_DENY_DOS) ||
3252                  access_mask & (FILE_READ_ATTRIBUTES|FILE_READ_DATA|
3253                                 FILE_READ_EA|FILE_EXECUTE));
3254
3255         if (!need_read) {
3256                 return O_WRONLY;
3257         }
3258         return O_RDWR;
3259 }
3260
3261 /****************************************************************************
3262  Open a file with a share mode. Passed in an already created files_struct *.
3263 ****************************************************************************/
3264
3265 static NTSTATUS open_file_ntcreate(connection_struct *conn,
3266                             struct smb_request *req,
3267                             uint32_t access_mask,               /* access bits (FILE_READ_DATA etc.) */
3268                             uint32_t share_access,      /* share constants (FILE_SHARE_READ etc) */
3269                             uint32_t create_disposition,        /* FILE_OPEN_IF etc. */
3270                             uint32_t create_options,    /* options such as delete on close. */
3271                             uint32_t new_dos_attributes,        /* attributes used for new file. */
3272                             int oplock_request,         /* internal Samba oplock codes. */
3273                             const struct smb2_lease *lease,
3274                                                         /* Information (FILE_EXISTS etc.) */
3275                             uint32_t private_flags,     /* Samba specific flags. */
3276                             int *pinfo,
3277                             files_struct *fsp)
3278 {
3279         struct smb_filename *smb_fname = fsp->fsp_name;
3280         int flags=0;
3281         int flags2=0;
3282         bool file_existed = VALID_STAT(smb_fname->st);
3283         bool def_acl = False;
3284         bool posix_open = False;
3285         bool new_file_created = False;
3286         bool first_open_attempt = true;
3287         NTSTATUS fsp_open = NT_STATUS_ACCESS_DENIED;
3288         mode_t new_unx_mode = (mode_t)0;
3289         mode_t unx_mode = (mode_t)0;
3290         int info;
3291         uint32_t existing_dos_attributes = 0;
3292         struct share_mode_lock *lck = NULL;
3293         uint32_t open_access_mask = access_mask;
3294         NTSTATUS status;
3295         char *parent_dir;
3296         SMB_STRUCT_STAT saved_stat = smb_fname->st;
3297         struct timespec old_write_time;
3298         struct file_id id;
3299         bool ok;
3300
3301         if (conn->printer) {
3302                 /*
3303                  * Printers are handled completely differently.
3304                  * Most of the passed parameters are ignored.
3305                  */
3306
3307                 if (pinfo) {
3308                         *pinfo = FILE_WAS_CREATED;
3309                 }
3310
3311                 DEBUG(10, ("open_file_ntcreate: printer open fname=%s\n",
3312                            smb_fname_str_dbg(smb_fname)));
3313
3314                 if (!req) {
3315                         DEBUG(0,("open_file_ntcreate: printer open without "
3316                                 "an SMB request!\n"));
3317                         return NT_STATUS_INTERNAL_ERROR;
3318                 }
3319
3320                 return print_spool_open(fsp, smb_fname->base_name,
3321                                         req->vuid);
3322         }
3323
3324         if (!parent_dirname(talloc_tos(), smb_fname->base_name, &parent_dir,
3325                             NULL)) {
3326                 return NT_STATUS_NO_MEMORY;
3327         }
3328
3329         if (new_dos_attributes & FILE_FLAG_POSIX_SEMANTICS) {
3330                 posix_open = True;
3331                 unx_mode = (mode_t)(new_dos_attributes & ~FILE_FLAG_POSIX_SEMANTICS);
3332                 new_dos_attributes = 0;
3333         } else {
3334                 /* Windows allows a new file to be created and
3335                    silently removes a FILE_ATTRIBUTE_DIRECTORY
3336                    sent by the client. Do the same. */
3337
3338                 new_dos_attributes &= ~FILE_ATTRIBUTE_DIRECTORY;
3339
3340                 /* We add FILE_ATTRIBUTE_ARCHIVE to this as this mode is only used if the file is
3341                  * created new. */
3342                 unx_mode = unix_mode(conn, new_dos_attributes | FILE_ATTRIBUTE_ARCHIVE,
3343                                      smb_fname, parent_dir);
3344         }
3345
3346         DEBUG(10, ("open_file_ntcreate: fname=%s, dos_attrs=0x%x "
3347                    "access_mask=0x%x share_access=0x%x "
3348                    "create_disposition = 0x%x create_options=0x%x "
3349                    "unix mode=0%o oplock_request=%d private_flags = 0x%x\n",
3350                    smb_fname_str_dbg(smb_fname), new_dos_attributes,
3351                    access_mask, share_access, create_disposition,
3352                    create_options, (unsigned int)unx_mode, oplock_request,
3353                    (unsigned int)private_flags));
3354
3355         if (req == NULL) {
3356                 /* Ensure req == NULL means INTERNAL_OPEN_ONLY */
3357                 SMB_ASSERT(oplock_request == INTERNAL_OPEN_ONLY);
3358         } else {
3359                 /* And req != NULL means no INTERNAL_OPEN_ONLY */
3360                 SMB_ASSERT(((oplock_request & INTERNAL_OPEN_ONLY) == 0));
3361         }
3362
3363         /*
3364          * Only non-internal opens can be deferred at all
3365          */
3366
3367         if (req) {
3368                 struct deferred_open_record *open_rec;
3369                 if (get_deferred_open_message_state(req, NULL, &open_rec)) {
3370
3371                         /* If it was an async create retry, the file
3372                            didn't exist. */
3373
3374                         if (is_deferred_open_async(open_rec)) {
3375                                 SET_STAT_INVALID(smb_fname->st);
3376                                 file_existed = false;
3377                         }
3378
3379                         /* Ensure we don't reprocess this message. */
3380                         remove_deferred_open_message_smb(req->xconn, req->mid);
3381
3382                         first_open_attempt = false;
3383                 }
3384         }
3385
3386         if (!posix_open) {
3387                 new_dos_attributes &= SAMBA_ATTRIBUTES_MASK;
3388                 if (file_existed) {
3389                         /*
3390                          * Only use stored DOS attributes for checks
3391                          * against requested attributes (below via
3392                          * open_match_attributes()), cf bug #11992
3393                          * for details. -slow
3394                          */
3395                         uint32_t attr = 0;
3396
3397                         status = SMB_VFS_GET_DOS_ATTRIBUTES(conn, smb_fname, &attr);
3398                         if (NT_STATUS_IS_OK(status)) {
3399                                 existing_dos_attributes = attr;
3400                         }
3401                 }
3402         }
3403
3404         /* ignore any oplock requests if oplocks are disabled */
3405         if (!lp_oplocks(SNUM(conn)) ||
3406             IS_VETO_OPLOCK_PATH(conn, smb_fname->base_name)) {
3407                 /* Mask off everything except the private Samba bits. */
3408                 oplock_request &= SAMBA_PRIVATE_OPLOCK_MASK;
3409         }
3410
3411         /* this is for OS/2 long file names - say we don't support them */
3412         if (req != NULL && !req->posix_pathnames &&
3413                         strstr(smb_fname->base_name,".+,;=[].")) {
3414                 /* OS/2 Workplace shell fix may be main code stream in a later
3415                  * release. */
3416                 DEBUG(5,("open_file_ntcreate: OS/2 long filenames are not "
3417                          "supported.\n"));
3418                 if (use_nt_status()) {
3419                         return NT_STATUS_OBJECT_NAME_NOT_FOUND;
3420                 }
3421                 return NT_STATUS_DOS(ERRDOS, ERRcannotopen);
3422         }
3423
3424         switch( create_disposition ) {
3425                 case FILE_OPEN:
3426                         /* If file exists open. If file doesn't exist error. */
3427                         if (!file_existed) {
3428                                 DEBUG(5,("open_file_ntcreate: FILE_OPEN "
3429                                          "requested for file %s and file "
3430                                          "doesn't exist.\n",
3431                                          smb_fname_str_dbg(smb_fname)));
3432                                 errno = ENOENT;
3433                                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
3434                         }
3435                         break;
3436
3437                 case FILE_OVERWRITE:
3438                         /* If file exists overwrite. If file doesn't exist
3439                          * error. */
3440                         if (!file_existed) {
3441                                 DEBUG(5,("open_file_ntcreate: FILE_OVERWRITE "
3442                                          "requested for file %s and file "
3443                                          "doesn't exist.\n",
3444                                          smb_fname_str_dbg(smb_fname) ));
3445                                 errno = ENOENT;
3446                                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
3447                         }
3448                         break;
3449
3450                 case FILE_CREATE:
3451                         /* If file exists error. If file doesn't exist
3452                          * create. */
3453                         if (file_existed) {
3454                                 DEBUG(5,("open_file_ntcreate: FILE_CREATE "
3455                                          "requested for file %s and file "
3456                                          "already exists.\n",
3457                                          smb_fname_str_dbg(smb_fname)));
3458                                 if (S_ISDIR(smb_fname->st.st_ex_mode)) {
3459                                         errno = EISDIR;
3460                                 } else {
3461                                         errno = EEXIST;
3462                                 }
3463                                 return map_nt_error_from_unix(errno);
3464                         }
3465                         break;
3466
3467                 case FILE_SUPERSEDE:
3468                 case FILE_OVERWRITE_IF:
3469                 case FILE_OPEN_IF:
3470                         break;
3471                 default:
3472                         return NT_STATUS_INVALID_PARAMETER;
3473         }
3474
3475         flags2 = disposition_to_open_flags(create_disposition);
3476
3477         /* We only care about matching attributes on file exists and
3478          * overwrite. */
3479
3480         if (!posix_open && file_existed &&
3481             ((create_disposition == FILE_OVERWRITE) ||
3482              (create_disposition == FILE_OVERWRITE_IF))) {
3483                 if (!open_match_attributes(conn, existing_dos_attributes,
3484                                            new_dos_attributes,
3485                                            unx_mode, &new_unx_mode)) {
3486                         DEBUG(5,("open_file_ntcreate: attributes mismatch "
3487                                  "for file %s (%x %x) (0%o, 0%o)\n",
3488                                  smb_fname_str_dbg(smb_fname),
3489                                  existing_dos_attributes,
3490                                  new_dos_attributes,
3491                                  (unsigned int)smb_fname->st.st_ex_mode,
3492                                  (unsigned int)unx_mode ));
3493                         errno = EACCES;
3494                         return NT_STATUS_ACCESS_DENIED;
3495                 }
3496         }
3497
3498         status = smbd_calculate_access_mask(conn, smb_fname,
3499                                         false,
3500                                         access_mask,
3501                                         &access_mask);
3502         if (!NT_STATUS_IS_OK(status)) {
3503                 DEBUG(10, ("open_file_ntcreate: smbd_calculate_access_mask "
3504                         "on file %s returned %s\n",
3505                         smb_fname_str_dbg(smb_fname), nt_errstr(status)));
3506                 return status;
3507         }
3508
3509         open_access_mask = access_mask;
3510
3511         if (flags2 & O_TRUNC) {
3512                 open_access_mask |= FILE_WRITE_DATA; /* This will cause oplock breaks. */
3513         }
3514
3515         if (file_existed) {
3516                 /*
3517                  * stat opens on existing files don't get oplocks.
3518                  * They can get leases.
3519                  *
3520                  * Note that we check for stat open on the *open_access_mask*,
3521                  * i.e. the access mask we actually used to do the open,
3522                  * not the one the client asked for (which is in
3523                  * fsp->access_mask). This is due to the fact that
3524                  * FILE_OVERWRITE and FILE_OVERWRITE_IF add in O_TRUNC,
3525                  * which adds FILE_WRITE_DATA to open_access_mask.
3526                  */
3527                 if (is_stat_open(open_access_mask) && lease == NULL) {
3528                         oplock_request = NO_OPLOCK;
3529                 }
3530         }
3531
3532         DEBUG(10, ("open_file_ntcreate: fname=%s, after mapping "
3533                    "access_mask=0x%x\n", smb_fname_str_dbg(smb_fname),
3534                     access_mask));
3535
3536         /*
3537          * Note that we ignore the append flag as append does not
3538          * mean the same thing under DOS and Unix.
3539          */
3540
3541         flags = calculate_open_access_flags(access_mask, private_flags);
3542
3543         /*
3544          * Currently we only look at FILE_WRITE_THROUGH for create options.
3545          */
3546
3547 #if defined(O_SYNC)
3548         if ((create_options & FILE_WRITE_THROUGH) && lp_strict_sync(SNUM(conn))) {
3549                 flags2 |= O_SYNC;
3550         }
3551 #endif /* O_SYNC */
3552
3553         if (posix_open && (access_mask & FILE_APPEND_DATA)) {
3554                 flags2 |= O_APPEND;
3555         }
3556
3557         if (!posix_open && !CAN_WRITE(conn)) {
3558                 /*
3559                  * We should really return a permission denied error if either
3560                  * O_CREAT or O_TRUNC are set, but for compatibility with
3561                  * older versions of Samba we just AND them out.
3562                  */
3563                 flags2 &= ~(O_CREAT|O_TRUNC);
3564         }
3565
3566         /*
3567          * With kernel oplocks the open breaking an oplock
3568          * blocks until the oplock holder has given up the
3569          * oplock or closed the file. We prevent this by always
3570          * trying to open the file with O_NONBLOCK (see "man
3571          * fcntl" on Linux).
3572          *
3573          * If a process that doesn't use the smbd open files
3574          * database or communication methods holds a kernel
3575          * oplock we must periodically poll for available open
3576          * using O_NONBLOCK.
3577          */
3578         flags2 |= O_NONBLOCK;
3579
3580         /*
3581          * Ensure we can't write on a read-only share or file.
3582          */
3583
3584         if (flags != O_RDONLY && file_existed &&
3585             (!CAN_WRITE(conn) || IS_DOS_READONLY(existing_dos_attributes))) {
3586                 DEBUG(5,("open_file_ntcreate: write access requested for "
3587                          "file %s on read only %s\n",
3588                          smb_fname_str_dbg(smb_fname),
3589                          !CAN_WRITE(conn) ? "share" : "file" ));
3590                 errno = EACCES;
3591                 return NT_STATUS_ACCESS_DENIED;
3592         }
3593
3594         fsp->file_id = vfs_file_id_from_sbuf(conn, &smb_fname->st);
3595         fsp->fh->private_options = private_flags;
3596         fsp->access_mask = open_access_mask; /* We change this to the
3597                                               * requested access_mask after
3598                                               * the open is done. */
3599         if (posix_open) {
3600                 fsp->posix_flags |= FSP_POSIX_FLAGS_ALL;
3601         }
3602
3603         if ((create_options & FILE_DELETE_ON_CLOSE) &&
3604                         (flags2 & O_CREAT) &&
3605                         !file_existed) {
3606                 /* Delete on close semantics for new files. */
3607                 status = can_set_delete_on_close(fsp,
3608                                                 new_dos_attributes);
3609                 if (!NT_STATUS_IS_OK(status)) {
3610                         fd_close(fsp);
3611                         return status;
3612                 }
3613         }
3614
3615         /*
3616          * Ensure we pay attention to default ACLs on directories if required.
3617          */
3618
3619         if ((flags2 & O_CREAT) && lp_inherit_acls(SNUM(conn)) &&
3620             (def_acl = directory_has_default_acl(conn, parent_dir))) {
3621                 unx_mode = (0777 & lp_create_mask(SNUM(conn)));
3622         }
3623
3624         DEBUG(4,("calling open_file with flags=0x%X flags2=0x%X mode=0%o, "
3625                 "access_mask = 0x%x, open_access_mask = 0x%x\n",
3626                  (unsigned int)flags, (unsigned int)flags2,
3627                  (unsigned int)unx_mode, (unsigned int)access_mask,
3628                  (unsigned int)open_access_mask));
3629
3630         fsp_open = open_file(fsp, conn, req, parent_dir,
3631                              flags|flags2, unx_mode, access_mask,
3632                              open_access_mask, &new_file_created);
3633
3634         if (NT_STATUS_EQUAL(fsp_open, NT_STATUS_NETWORK_BUSY)) {
3635                 /*
3636                  * This handles the kernel oplock case:
3637                  *
3638                  * the file has an active kernel oplock and the open() returned
3639                  * EWOULDBLOCK/EAGAIN which maps to NETWORK_BUSY.
3640                  *
3641                  * "Samba locking.tdb oplocks" are handled below after acquiring
3642                  * the sharemode lock with get_share_mode_lock().
3643                  */
3644                 if (file_existed && S_ISFIFO(fsp->fsp_name->st.st_ex_mode)) {
3645                         DEBUG(10, ("FIFO busy\n"));
3646                         return NT_STATUS_NETWORK_BUSY;
3647                 }
3648                 if (req == NULL) {
3649                         DEBUG(10, ("Internal open busy\n"));
3650                         return NT_STATUS_NETWORK_BUSY;
3651                 }
3652
3653                 /*
3654                  * From here on we assume this is an oplock break triggered
3655                  */
3656
3657                 lck = get_existing_share_mode_lock(talloc_tos(), fsp->file_id);
3658
3659                 if ((lck != NULL) && !validate_oplock_types(lck)) {
3660                         smb_panic("validate_oplock_types failed");
3661                 }
3662
3663                 /*
3664                  * Retry once a second. If there's a share_mode_lock
3665                  * around, also wait for it in case it was smbd
3666                  * holding that kernel oplock that can quickly tell us
3667                  * the oplock got removed.
3668                  */
3669
3670                 setup_poll_open(
3671                         req,
3672                         lck,
3673                         fsp->file_id,
3674                         timeval_set(OPLOCK_BREAK_TIMEOUT*2, 0),
3675                         timeval_set(1, 0));
3676
3677                 TALLOC_FREE(lck);
3678
3679                 return NT_STATUS_SHARING_VIOLATION;
3680         }
3681
3682         if (!NT_STATUS_IS_OK(fsp_open)) {
3683                 if (NT_STATUS_EQUAL(fsp_open, NT_STATUS_RETRY)) {
3684                         schedule_async_open(req);
3685                 }
3686                 return fsp_open;
3687         }
3688
3689         if (new_file_created) {
3690                 /*
3691                  * As we atomically create using O_CREAT|O_EXCL,
3692                  * then if new_file_created is true, then
3693                  * file_existed *MUST* have been false (even
3694                  * if the file was previously detected as being
3695                  * there).
3696                  */
3697                 file_existed = false;
3698         }
3699
3700         if (file_existed && !check_same_dev_ino(&saved_stat, &smb_fname->st)) {
3701                 /*
3702                  * The file did exist, but some other (local or NFS)
3703                  * process either renamed/unlinked and re-created the
3704                  * file with different dev/ino after we walked the path,
3705                  * but before we did the open. We could retry the
3706                  * open but it's a rare enough case it's easier to
3707                  * just fail the open to prevent creating any problems
3708                  * in the open file db having the wrong dev/ino key.
3709                  */
3710                 fd_close(fsp);
3711                 DBG_WARNING("file %s - dev/ino mismatch. "
3712                             "Old (dev=%ju, ino=%ju). "
3713                             "New (dev=%ju, ino=%ju). Failing open "
3714                             "with NT_STATUS_ACCESS_DENIED.\n",
3715                             smb_fname_str_dbg(smb_fname),
3716                             (uintmax_t)saved_stat.st_ex_dev,
3717                             (uintmax_t)saved_stat.st_ex_ino,
3718                             (uintmax_t)smb_fname->st.st_ex_dev,
3719                             (uintmax_t)smb_fname->st.st_ex_ino);
3720                 return NT_STATUS_ACCESS_DENIED;
3721         }
3722
3723         old_write_time = smb_fname->st.st_ex_mtime;
3724
3725         /*
3726          * Deal with the race condition where two smbd's detect the
3727          * file doesn't exist and do the create at the same time. One
3728          * of them will win and set a share mode, the other (ie. this
3729          * one) should check if the requested share mode for this
3730          * create is allowed.
3731          */
3732
3733         /*
3734          * Now the file exists and fsp is successfully opened,
3735          * fsp->dev and fsp->inode are valid and should replace the
3736          * dev=0,inode=0 from a non existent file. Spotted by
3737          * Nadav Danieli <nadavd@exanet.com>. JRA.
3738          */
3739
3740         id = fsp->file_id;
3741
3742         lck = get_share_mode_lock(talloc_tos(), id,
3743                                   conn->connectpath,
3744                                   smb_fname, &old_write_time);
3745
3746         if (lck == NULL) {
3747                 DEBUG(0, ("open_file_ntcreate: Could not get share "
3748                           "mode lock for %s\n",
3749                           smb_fname_str_dbg(smb_fname)));
3750                 fd_close(fsp);
3751                 return NT_STATUS_SHARING_VIOLATION;
3752         }
3753
3754         /* Get the types we need to examine. */
3755         if (!validate_oplock_types(lck)) {
3756                 smb_panic("validate_oplock_types failed");
3757         }
3758
3759         if (has_delete_on_close(lck, fsp->name_hash)) {
3760                 TALLOC_FREE(lck);
3761                 fd_close(fsp);
3762                 return NT_STATUS_DELETE_PENDING;
3763         }
3764
3765         status = handle_share_mode_lease(
3766                 fsp,
3767                 lck,
3768                 create_disposition,
3769                 access_mask,
3770                 share_access,
3771                 oplock_request,
3772                 lease,
3773                 first_open_attempt);
3774
3775         if (NT_STATUS_EQUAL(status, NT_STATUS_RETRY)) {
3776                 schedule_defer_open(lck, fsp->file_id, req);
3777                 TALLOC_FREE(lck);
3778                 fd_close(fsp);
3779                 return NT_STATUS_SHARING_VIOLATION;
3780         }
3781
3782         if (!NT_STATUS_IS_OK(status)) {
3783                 TALLOC_FREE(lck);
3784                 fd_close(fsp);
3785                 return status;
3786         }
3787
3788         {
3789                 struct share_mode_data *d = lck->data;
3790                 uint16_t new_flags = share_mode_flags_restrict(
3791                         d->flags, access_mask, share_access, UINT32_MAX);
3792
3793                 if (new_flags != d->flags) {
3794                         d->flags = new_flags;
3795                         d->modified = true;
3796                 }
3797         }
3798
3799         ok = set_share_mode(
3800                 lck,
3801                 fsp,
3802                 get_current_uid(fsp->conn),
3803                 req ? req->mid : 0,
3804                 fsp->oplock_type,
3805                 share_access,
3806                 access_mask);
3807         if (!ok) {
3808                 if (fsp->oplock_type == LEASE_OPLOCK) {
3809                         status = remove_lease_if_stale(
3810                                 lck,
3811                                 fsp_client_guid(fsp),
3812                                 &fsp->lease->lease.lease_key);
3813                         if (!NT_STATUS_IS_OK(status)) {
3814                                 DBG_WARNING("remove_lease_if_stale "
3815                                             "failed: %s\n",
3816                                             nt_errstr(status));
3817                         }
3818                 }
3819                 return NT_STATUS_NO_MEMORY;
3820         }
3821
3822         /* Should we atomically (to the client at least) truncate ? */
3823         if ((!new_file_created) &&
3824             (flags2 & O_TRUNC) &&
3825             (S_ISREG(fsp->fsp_name->st.st_ex_mode))) {
3826                 int ret;
3827
3828                 ret = SMB_VFS_FTRUNCATE(fsp, 0);
3829                 if (ret != 0) {
3830                         status = map_nt_error_from_unix(errno);
3831                         del_share_mode(lck, fsp);
3832                         TALLOC_FREE(lck);
3833                         fd_close(fsp);
3834                         return status;
3835                 }
3836                 notify_fname(fsp->conn, NOTIFY_ACTION_MODIFIED,
3837                              FILE_NOTIFY_CHANGE_SIZE
3838                              | FILE_NOTIFY_CHANGE_ATTRIBUTES,
3839                              fsp->fsp_name->base_name);
3840         }
3841
3842         /*
3843          * We have the share entry *locked*.....
3844          */
3845
3846         /* Delete streams if create_disposition requires it */
3847         if (!new_file_created && clear_ads(create_disposition) &&
3848             !is_ntfs_stream_smb_fname(smb_fname)) {
3849                 status = delete_all_streams(conn, smb_fname);
3850                 if (!NT_STATUS_IS_OK(status)) {
3851                         del_share_mode(lck, fsp);
3852                         TALLOC_FREE(lck);
3853                         fd_close(fsp);
3854                         return status;
3855                 }
3856         }
3857
3858         if (fsp->fh->fd != -1 && lp_kernel_share_modes(SNUM(conn))) {
3859                 int ret_flock;
3860                 /*
3861                  * Beware: streams implementing VFS modules may
3862                  * implement streams in a way that fsp will have the
3863                  * basefile open in the fsp fd, so lacking a distinct
3864                  * fd for the stream kernel_flock will apply on the
3865                  * basefile which is wrong. The actual check is
3866                  * deferred to the VFS module implementing the
3867                  * kernel_flock call.
3868                  */
3869                 ret_flock = SMB_VFS_KERNEL_FLOCK(fsp, share_access, access_mask);
3870                 if(ret_flock == -1 ){
3871
3872                         del_share_mode(lck, fsp);
3873                         TALLOC_FREE(lck);
3874                         fd_close(fsp);
3875
3876                         return NT_STATUS_SHARING_VIOLATION;
3877                 }
3878
3879                 fsp->kernel_share_modes_taken = true;
3880         }
3881
3882         /*
3883          * At this point onwards, we can guarantee that the share entry
3884          * is locked, whether we created the file or not, and that the
3885          * deny mode is compatible with all current opens.
3886          */
3887
3888         /*
3889          * According to Samba4, SEC_FILE_READ_ATTRIBUTE is always granted,
3890          * but we don't have to store this - just ignore it on access check.
3891          */
3892         if (conn->sconn->using_smb2) {
3893                 /*
3894                  * SMB2 doesn't return it (according to Microsoft tests).
3895                  * Test Case: TestSuite_ScenarioNo009GrantedAccessTestS0
3896                  * File created with access = 0x7 (Read, Write, Delete)
3897                  * Query Info on file returns 0x87 (Read, Write, Delete, Read Attributes)
3898                  */
3899                 fsp->access_mask = access_mask;
3900         } else {
3901                 /* But SMB1 does. */
3902                 fsp->access_mask = access_mask | FILE_READ_ATTRIBUTES;
3903         }
3904
3905         if (new_file_created) {
3906                 info = FILE_WAS_CREATED;
3907         } else {
3908                 if (flags2 & O_TRUNC) {
3909                         info = FILE_WAS_OVERWRITTEN;
3910                 } else {
3911                         info = FILE_WAS_OPENED;
3912                 }
3913         }
3914
3915         if (pinfo) {
3916                 *pinfo = info;
3917         }
3918
3919         /* Handle strange delete on close create semantics. */
3920         if (create_options & FILE_DELETE_ON_CLOSE) {
3921                 if (!new_file_created) {
3922                         status = can_set_delete_on_close(fsp,
3923                                          existing_dos_attributes);
3924
3925                         if (!NT_STATUS_IS_OK(status)) {
3926                                 /* Remember to delete the mode we just added. */
3927                                 del_share_mode(lck, fsp);
3928                                 TALLOC_FREE(lck);
3929                                 fd_close(fsp);
3930                                 return status;
3931                         }
3932                 }
3933                 /* Note that here we set the *initial* delete on close flag,
3934                    not the regular one. The magic gets handled in close. */
3935                 fsp->initial_delete_on_close = True;
3936         }
3937
3938         /*
3939          * If we created a file and it's not a stream, this is the point where
3940          * we set the itime (aka invented time) that get's stored in the DOS
3941          * attribute xattr. The value is going to be either what the filesystem
3942          * provided or a copy of the creation date.
3943          *
3944          * Either way, we turn the itime into a File-ID, unless the filesystem
3945          * provided one (unlikely).
3946          */
3947         if (info == FILE_WAS_CREATED && !is_named_stream(smb_fname)) {
3948                 smb_fname->st.st_ex_iflags &= ~ST_EX_IFLAG_CALCULATED_ITIME;
3949
3950                 if (lp_store_dos_attributes(SNUM(conn)) &&
3951                     smb_fname->st.st_ex_iflags & ST_EX_IFLAG_CALCULATED_FILE_ID)
3952                 {
3953                         uint64_t file_id;
3954
3955                         file_id = make_file_id_from_itime(&smb_fname->st);
3956                         update_stat_ex_file_id(&smb_fname->st, file_id);
3957                 }
3958         }
3959
3960         if (info != FILE_WAS_OPENED) {
3961                 /* Overwritten files should be initially set as archive */
3962                 if ((info == FILE_WAS_OVERWRITTEN && lp_map_archive(SNUM(conn))) ||
3963                     lp_store_dos_attributes(SNUM(conn))) {
3964                         (void)dos_mode(conn, smb_fname);
3965                         if (!posix_open) {
3966                                 if (file_set_dosmode(conn, smb_fname,
3967                                             new_dos_attributes | FILE_ATTRIBUTE_ARCHIVE,
3968                                             parent_dir, true) == 0) {
3969                                         unx_mode = smb_fname->st.st_ex_mode;
3970                                 }
3971                         }
3972                 }
3973         }
3974
3975         /* Determine sparse flag. */
3976         if (posix_open) {
3977                 /* POSIX opens are sparse by default. */
3978                 fsp->is_sparse = true;
3979         } else {
3980                 fsp->is_sparse =
3981                         (existing_dos_attributes & FILE_ATTRIBUTE_SPARSE);
3982         }
3983
3984         /*
3985          * Take care of inherited ACLs on created files - if default ACL not
3986          * selected.
3987          */
3988
3989         if (!posix_open && new_file_created && !def_acl) {
3990                 if (unx_mode != smb_fname->st.st_ex_mode) {
3991                         int ret = SMB_VFS_FCHMOD(fsp, unx_mode);
3992                         if (ret == -1) {
3993                                 DBG_INFO("failed to reset "
3994                                   "attributes of file %s to 0%o\n",
3995                                   smb_fname_str_dbg(smb_fname),
3996                                   (unsigned int)unx_mode);
3997                         }
3998                 }
3999
4000         } else if (new_unx_mode) {
4001                 /*
4002                  * We only get here in the case of:
4003                  *
4004                  * a). Not a POSIX open.
4005                  * b). File already existed.
4006                  * c). File was overwritten.
4007                  * d). Requested DOS attributes didn't match
4008                  *     the DOS attributes on the existing file.
4009                  *
4010                  * In that case new_unx_mode has been set
4011                  * equal to the calculated mode (including
4012                  * possible inheritance of the mode from the
4013                  * containing directory).
4014                  *
4015                  * Note this mode was calculated with the
4016                  * DOS attribute FILE_ATTRIBUTE_ARCHIVE added,
4017                  * so the mode change here is suitable for
4018                  * an overwritten file.
4019                  */
4020
4021                 if (new_unx_mode != smb_fname->st.st_ex_mode) {
4022                         int ret = SMB_VFS_FCHMOD(fsp, new_unx_mode);
4023                         if (ret == -1) {
4024                                 DBG_INFO("failed to reset "
4025                                   "attributes of file %s to 0%o\n",
4026                                   smb_fname_str_dbg(smb_fname),
4027                                   (unsigned int)new_unx_mode);
4028                         }
4029                 }
4030         }
4031
4032         {
4033                 /*
4034                  * Deal with other opens having a modified write time.
4035                  */
4036                 struct timespec write_time = get_share_mode_write_time(lck);
4037
4038                 if (!is_omit_timespec(&write_time)) {
4039                         update_stat_ex_mtime(&fsp->fsp_name->st, write_time);
4040                 }
4041         }
4042
4043         TALLOC_FREE(lck);
4044
4045         return NT_STATUS_OK;
4046 }
4047
4048 static NTSTATUS mkdir_internal(connection_struct *conn,
4049                                struct smb_filename *smb_dname,
4050                                uint32_t file_attributes)
4051 {
4052         const struct loadparm_substitution *lp_sub =
4053                 loadparm_s3_global_substitution();
4054         mode_t mode;
4055         char *parent_dir = NULL;
4056         NTSTATUS status;
4057         bool posix_open = false;
4058         bool need_re_stat = false;
4059         uint32_t access_mask = SEC_DIR_ADD_SUBDIR;
4060         int ret;
4061
4062         if (!CAN_WRITE(conn) || (access_mask & ~(conn->share_access))) {
4063                 DEBUG(5,("mkdir_internal: failing share access "
4064                          "%s\n", lp_servicename(talloc_tos(), lp_sub, SNUM(conn))));
4065                 return NT_STATUS_ACCESS_DENIED;
4066         }
4067
4068         if (!parent_dirname(talloc_tos(), smb_dname->base_name, &parent_dir,
4069                             NULL)) {
4070                 return NT_STATUS_NO_MEMORY;
4071         }
4072
4073         if (file_attributes & FILE_FLAG_POSIX_SEMANTICS) {
4074                 posix_open = true;
4075                 mode = (mode_t)(file_attributes & ~FILE_FLAG_POSIX_SEMANTICS);
4076         } else {
4077                 mode = unix_mode(conn, FILE_ATTRIBUTE_DIRECTORY, smb_dname, parent_dir);
4078         }
4079
4080         status = check_parent_access(conn,
4081                                         smb_dname,
4082                                         access_mask);
4083         if(!NT_STATUS_IS_OK(status)) {
4084                 DEBUG(5,("mkdir_internal: check_parent_access "
4085                         "on directory %s for path %s returned %s\n",
4086                         parent_dir,
4087                         smb_dname->base_name,
4088                         nt_errstr(status) ));
4089                 return status;
4090         }
4091
4092         ret = SMB_VFS_MKDIRAT(conn,
4093                         conn->cwd_fsp,
4094                         smb_dname,
4095                         mode);
4096         if (ret != 0) {
4097                 return map_nt_error_from_unix(errno);
4098         }
4099
4100         /* Ensure we're checking for a symlink here.... */
4101         /* We don't want to get caught by a symlink racer. */
4102
4103         if (SMB_VFS_LSTAT(conn, smb_dname) == -1) {
4104                 DEBUG(2, ("Could not stat directory '%s' just created: %s\n",
4105                           smb_fname_str_dbg(smb_dname), strerror(errno)));
4106                 return map_nt_error_from_unix(errno);
4107         }
4108
4109         if (!S_ISDIR(smb_dname->st.st_ex_mode)) {
4110                 DEBUG(0, ("Directory '%s' just created is not a directory !\n",
4111                           smb_fname_str_dbg(smb_dname)));
4112                 return NT_STATUS_NOT_A_DIRECTORY;
4113         }
4114
4115         smb_dname->st.st_ex_iflags &= ~ST_EX_IFLAG_CALCULATED_ITIME;
4116
4117         if (lp_store_dos_attributes(SNUM(conn))) {
4118                 if (smb_dname->st.st_ex_iflags & ST_EX_IFLAG_CALCULATED_FILE_ID)
4119                 {
4120                         uint64_t file_id;
4121
4122                         file_id = make_file_id_from_itime(&smb_dname->st);
4123                         update_stat_ex_file_id(&smb_dname->st, file_id);
4124                 }
4125
4126                 if (!posix_open) {
4127                         file_set_dosmode(conn, smb_dname,
4128                                          file_attributes | FILE_ATTRIBUTE_DIRECTORY,
4129                                          parent_dir, true);
4130                 }
4131         }
4132
4133         if (lp_inherit_permissions(SNUM(conn))) {
4134                 inherit_access_posix_acl(conn, parent_dir,
4135                                          smb_dname, mode);
4136                 need_re_stat = true;
4137         }
4138
4139         if (!posix_open) {
4140                 /*
4141                  * Check if high bits should have been set,
4142                  * then (if bits are missing): add them.
4143                  * Consider bits automagically set by UNIX, i.e. SGID bit from parent
4144                  * dir.
4145                  */
4146                 if ((mode & ~(S_IRWXU|S_IRWXG|S_IRWXO)) &&
4147                     (mode & ~smb_dname->st.st_ex_mode)) {
4148                         SMB_VFS_CHMOD(conn, smb_dname,
4149                                       (smb_dname->st.st_ex_mode |
4150                                           (mode & ~smb_dname->st.st_ex_mode)));
4151                         need_re_stat = true;
4152                 }
4153         }
4154
4155         /* Change the owner if required. */
4156         if (lp_inherit_owner(SNUM(conn)) != INHERIT_OWNER_NO) {
4157                 change_dir_owner_to_parent(conn, parent_dir,
4158                                            smb_dname,
4159                                            &smb_dname->st);
4160                 need_re_stat = true;
4161         }
4162
4163         if (need_re_stat) {
4164                 if (SMB_VFS_LSTAT(conn, smb_dname) == -1) {
4165                         DEBUG(2, ("Could not stat directory '%s' just created: %s\n",
4166                           smb_fname_str_dbg(smb_dname), strerror(errno)));
4167                         return map_nt_error_from_unix(errno);
4168                 }
4169         }
4170
4171         notify_fname(conn, NOTIFY_ACTION_ADDED, FILE_NOTIFY_CHANGE_DIR_NAME,
4172                      smb_dname->base_name);
4173
4174         return NT_STATUS_OK;
4175 }
4176
4177 /****************************************************************************
4178  Open a directory from an NT SMB call.
4179 ****************************************************************************/
4180
4181 static NTSTATUS open_directory(connection_struct *conn,
4182                                struct smb_request *req,
4183                                struct smb_filename *smb_dname,
4184                                uint32_t access_mask,
4185                                uint32_t share_access,
4186                                uint32_t create_disposition,
4187                                uint32_t create_options,
4188                                uint32_t file_attributes,
4189                                int *pinfo,
4190                                files_struct **result)
4191 {
4192         files_struct *fsp = NULL;
4193         bool dir_existed = VALID_STAT(smb_dname->st) ? True : False;
4194         struct share_mode_lock *lck = NULL;
4195         NTSTATUS status;
4196         struct timespec mtimespec;
4197         int info = 0;
4198         bool ok;
4199
4200         if (is_ntfs_stream_smb_fname(smb_dname)) {
4201                 DEBUG(2, ("open_directory: %s is a stream name!\n",
4202                           smb_fname_str_dbg(smb_dname)));
4203                 return NT_STATUS_NOT_A_DIRECTORY;
4204         }
4205
4206         if (!(file_attributes & FILE_FLAG_POSIX_SEMANTICS)) {
4207                 /* Ensure we have a directory attribute. */
4208                 file_attributes |= FILE_ATTRIBUTE_DIRECTORY;
4209         }
4210
4211         DEBUG(5,("open_directory: opening directory %s, access_mask = 0x%x, "
4212                  "share_access = 0x%x create_options = 0x%x, "
4213                  "create_disposition = 0x%x, file_attributes = 0x%x\n",
4214                  smb_fname_str_dbg(smb_dname),
4215                  (unsigned int)access_mask,
4216                  (unsigned int)share_access,
4217                  (unsigned int)create_options,
4218                  (unsigned int)create_disposition,
4219                  (unsigned int)file_attributes));
4220
4221         status = smbd_calculate_access_mask(conn, smb_dname, false,
4222                                             access_mask, &access_mask);
4223         if (!NT_STATUS_IS_OK(status)) {
4224                 DEBUG(10, ("open_directory: smbd_calculate_access_mask "
4225                         "on file %s returned %s\n",
4226                         smb_fname_str_dbg(smb_dname),
4227                         nt_errstr(status)));
4228                 return status;
4229         }
4230
4231         if ((access_mask & SEC_FLAG_SYSTEM_SECURITY) &&
4232                         !security_token_has_privilege(get_current_nttok(conn),
4233                                         SEC_PRIV_SECURITY)) {
4234                 DEBUG(10, ("open_directory: open on %s "
4235                         "failed - SEC_FLAG_SYSTEM_SECURITY denied.\n",
4236                         smb_fname_str_dbg(smb_dname)));
4237                 return NT_STATUS_PRIVILEGE_NOT_HELD;
4238         }
4239
4240         switch( create_disposition ) {
4241                 case FILE_OPEN:
4242
4243                         if (!dir_existed) {
4244                                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
4245                         }
4246
4247                         info = FILE_WAS_OPENED;
4248                         break;
4249
4250                 case FILE_CREATE:
4251
4252                         /* If directory exists error. If directory doesn't
4253                          * exist create. */
4254
4255                         if (dir_existed) {
4256                                 status = NT_STATUS_OBJECT_NAME_COLLISION;
4257                                 DEBUG(2, ("open_directory: unable to create "
4258                                           "%s. Error was %s\n",
4259                                           smb_fname_str_dbg(smb_dname),
4260                                           nt_errstr(status)));
4261                                 return status;
4262                         }
4263
4264                         status = mkdir_internal(conn, smb_dname,
4265                                                 file_attributes);
4266
4267                         if (!NT_STATUS_IS_OK(status)) {
4268                                 DEBUG(2, ("open_directory: unable to create "
4269                                           "%s. Error was %s\n",
4270                                           smb_fname_str_dbg(smb_dname),
4271                                           nt_errstr(status)));
4272                                 return status;
4273                         }
4274
4275                         info = FILE_WAS_CREATED;
4276                         break;
4277
4278                 case FILE_OPEN_IF:
4279                         /*
4280                          * If directory exists open. If directory doesn't
4281                          * exist create.
4282                          */
4283
4284                         if (dir_existed) {
4285                                 status = NT_STATUS_OK;
4286                                 info = FILE_WAS_OPENED;
4287                         } else {
4288                                 status = mkdir_internal(conn, smb_dname,
4289                                                 file_attributes);
4290
4291                                 if (NT_STATUS_IS_OK(status)) {
4292                                         info = FILE_WAS_CREATED;
4293                                 } else {
4294                                         /* Cope with create race. */
4295                                         if (!NT_STATUS_EQUAL(status,
4296                                                         NT_STATUS_OBJECT_NAME_COLLISION)) {
4297                                                 DEBUG(2, ("open_directory: unable to create "
4298                                                         "%s. Error was %s\n",
4299                                                         smb_fname_str_dbg(smb_dname),
4300                                                         nt_errstr(status)));
4301                                                 return status;
4302                                         }
4303
4304                                         /*
4305                                          * If mkdir_internal() returned
4306                                          * NT_STATUS_OBJECT_NAME_COLLISION
4307                                          * we still must lstat the path.
4308                                          */
4309
4310                                         if (SMB_VFS_LSTAT(conn, smb_dname)
4311                                                         == -1) {
4312                                                 DEBUG(2, ("Could not stat "
4313                                                         "directory '%s' just "
4314                                                         "opened: %s\n",
4315                                                         smb_fname_str_dbg(
4316                                                                 smb_dname),
4317                                                         strerror(errno)));
4318                                                 return map_nt_error_from_unix(
4319                                                                 errno);
4320                                         }
4321
4322                                         info = FILE_WAS_OPENED;
4323                                 }
4324                         }
4325
4326                         break;
4327
4328                 case FILE_SUPERSEDE:
4329                 case FILE_OVERWRITE:
4330                 case FILE_OVERWRITE_IF:
4331                 default:
4332                         DEBUG(5,("open_directory: invalid create_disposition "
4333                                  "0x%x for directory %s\n",
4334                                  (unsigned int)create_disposition,
4335                                  smb_fname_str_dbg(smb_dname)));
4336                         return NT_STATUS_INVALID_PARAMETER;
4337         }
4338
4339         if(!S_ISDIR(smb_dname->st.st_ex_mode)) {
4340                 DEBUG(5,("open_directory: %s is not a directory !\n",
4341                          smb_fname_str_dbg(smb_dname)));
4342                 return NT_STATUS_NOT_A_DIRECTORY;
4343         }
4344
4345         if (info == FILE_WAS_OPENED) {
4346                 status = smbd_check_access_rights(conn,
4347                                                 smb_dname,
4348                                                 false,
4349                                                 access_mask);
4350                 if (!NT_STATUS_IS_OK(status)) {
4351                         DEBUG(10, ("open_directory: smbd_check_access_rights on "
4352                                 "file %s failed with %s\n",
4353                                 smb_fname_str_dbg(smb_dname),
4354                                 nt_errstr(status)));
4355                         return status;
4356                 }
4357         }
4358
4359         status = file_new(req, conn, &fsp);
4360         if(!NT_STATUS_IS_OK(status)) {
4361                 return status;
4362         }
4363
4364         /*
4365          * Setup the files_struct for it.
4366          */
4367
4368         fsp->file_id = vfs_file_id_from_sbuf(conn, &smb_dname->st);
4369         fsp->vuid = req ? req->vuid : UID_FIELD_INVALID;
4370         fsp->file_pid = req ? req->smbpid : 0;
4371         fsp->can_lock = False;
4372         fsp->can_read = False;
4373         fsp->can_write = False;
4374
4375         fsp->fh->private_options = 0;
4376         /*
4377          * According to Samba4, SEC_FILE_READ_ATTRIBUTE is always granted,
4378          */
4379         fsp->access_mask = access_mask | FILE_READ_ATTRIBUTES;
4380         fsp->print_file = NULL;
4381         fsp->modified = False;
4382         fsp->oplock_type = NO_OPLOCK;
4383         fsp->sent_oplock_break = NO_BREAK_SENT;
4384         fsp->is_directory = True;
4385         if (file_attributes & FILE_FLAG_POSIX_SEMANTICS) {
4386                 fsp->posix_flags |= FSP_POSIX_FLAGS_ALL;
4387         }
4388         status = fsp_set_smb_fname(fsp, smb_dname);
4389         if (!NT_STATUS_IS_OK(status)) {
4390                 file_free(req, fsp);
4391                 return status;
4392         }
4393
4394         /* Don't store old timestamps for directory
4395            handles in the internal database. We don't
4396            update them in there if new objects
4397            are creaded in the directory. Currently
4398            we only update timestamps on file writes.
4399            See bug #9870.
4400         */
4401         mtimespec = make_omit_timespec();
4402
4403 #ifdef O_DIRECTORY
4404         status = fd_open(conn, fsp, O_RDONLY|O_DIRECTORY, 0);
4405 #else
4406         /* POSIX allows us to open a directory with O_RDONLY. */
4407         status = fd_open(conn, fsp, O_RDONLY, 0);
4408 #endif
4409         if (!NT_STATUS_IS_OK(status)) {
4410                 DBG_INFO("Could not open fd for "
4411                         "%s (%s)\n",
4412                         smb_fname_str_dbg(smb_dname),
4413                         nt_errstr(status));
4414                 file_free(req, fsp);
4415                 return status;
4416         }
4417
4418         status = vfs_stat_fsp(fsp);
4419         if (!NT_STATUS_IS_OK(status)) {
4420                 fd_close(fsp);
4421                 file_free(req, fsp);
4422                 return status;
4423         }
4424
4425         if(!S_ISDIR(fsp->fsp_name->st.st_ex_mode)) {
4426                 DEBUG(5,("open_directory: %s is not a directory !\n",
4427                          smb_fname_str_dbg(smb_dname)));
4428                 fd_close(fsp);
4429                 file_free(req, fsp);
4430                 return NT_STATUS_NOT_A_DIRECTORY;
4431         }
4432
4433         /* Ensure there was no race condition.  We need to check
4434          * dev/inode but not permissions, as these can change
4435          * legitimately */
4436         if (!check_same_dev_ino(&smb_dname->st, &fsp->fsp_name->st)) {
4437                 DEBUG(5,("open_directory: stat struct differs for "
4438                         "directory %s.\n",
4439                         smb_fname_str_dbg(smb_dname)));
4440                 fd_close(fsp);
4441                 file_free(req, fsp);
4442                 return NT_STATUS_ACCESS_DENIED;
4443         }
4444
4445         lck = get_share_mode_lock(talloc_tos(), fsp->file_id,
4446                                   conn->connectpath, smb_dname,
4447                                   &mtimespec);
4448
4449         if (lck == NULL) {
4450                 DEBUG(0, ("open_directory: Could not get share mode lock for "
4451                           "%s\n", smb_fname_str_dbg(smb_dname)));
4452                 fd_close(fsp);
4453                 file_free(req, fsp);
4454                 return NT_STATUS_SHARING_VIOLATION;
4455         }
4456
4457         if (has_delete_on_close(lck, fsp->name_hash)) {
4458                 TALLOC_FREE(lck);
4459                 fd_close(fsp);
4460                 file_free(req, fsp);
4461                 return NT_STATUS_DELETE_PENDING;
4462         }
4463
4464         status = open_mode_check(conn, lck,
4465                                  access_mask, share_access);
4466
4467         if (!NT_STATUS_IS_OK(status)) {
4468                 TALLOC_FREE(lck);
4469                 fd_close(fsp);
4470                 file_free(req, fsp);
4471                 return status;
4472         }
4473
4474         {
4475                 struct share_mode_data *d = lck->data;
4476                 uint16_t new_flags = share_mode_flags_restrict(
4477                         d->flags, access_mask, share_access, UINT32_MAX);
4478
4479                 if (new_flags != d->flags) {
4480                         d->flags = new_flags;
4481                         d->modified = true;
4482                 }
4483         }
4484
4485         ok = set_share_mode(
4486                 lck,
4487                 fsp,
4488                 get_current_uid(conn),
4489                 req ? req->mid : 0,
4490                 NO_OPLOCK,
4491                 share_access,
4492                 fsp->access_mask);
4493         if (!ok) {
4494                 TALLOC_FREE(lck);
4495                 fd_close(fsp);
4496                 file_free(req, fsp);
4497                 return NT_STATUS_NO_MEMORY;
4498         }
4499
4500         /* For directories the delete on close bit at open time seems
4501            always to be honored on close... See test 19 in Samba4 BASE-DELETE. */
4502         if (create_options & FILE_DELETE_ON_CLOSE) {
4503                 status = can_set_delete_on_close(fsp, 0);
4504                 if (!NT_STATUS_IS_OK(status) && !NT_STATUS_EQUAL(status, NT_STATUS_DIRECTORY_NOT_EMPTY)) {
4505                         del_share_mode(lck, fsp);
4506                         TALLOC_FREE(lck);
4507                         fd_close(fsp);
4508                         file_free(req, fsp);
4509                         return status;
4510                 }
4511
4512                 if (NT_STATUS_IS_OK(status)) {
4513                         /* Note that here we set the *initial* delete on close flag,
4514                            not the regular one. The magic gets handled in close. */
4515                         fsp->initial_delete_on_close = True;
4516                 }
4517         }
4518
4519         {
4520                 /*
4521                  * Deal with other opens having a modified write time. Is this
4522                  * possible for directories?
4523                  */
4524                 struct timespec write_time = get_share_mode_write_time(lck);
4525
4526                 if (!is_omit_timespec(&write_time)) {
4527                         update_stat_ex_mtime(&fsp->fsp_name->st, write_time);
4528                 }
4529         }
4530
4531         TALLOC_FREE(lck);
4532
4533         if (pinfo) {
4534                 *pinfo = info;
4535         }
4536
4537         *result = fsp;
4538         return NT_STATUS_OK;
4539 }
4540
4541 NTSTATUS create_directory(connection_struct *conn, struct smb_request *req,
4542                           struct smb_filename *smb_dname)
4543 {
4544         NTSTATUS status;
4545         files_struct *fsp;
4546
4547         status = SMB_VFS_CREATE_FILE(
4548                 conn,                                   /* conn */
4549                 req,                                    /* req */
4550                 0,                                      /* root_dir_fid */
4551                 smb_dname,                              /* fname */
4552                 FILE_READ_ATTRIBUTES,                   /* access_mask */
4553                 FILE_SHARE_NONE,                        /* share_access */
4554                 FILE_CREATE,                            /* create_disposition*/
4555                 FILE_DIRECTORY_FILE,                    /* create_options */
4556                 FILE_ATTRIBUTE_DIRECTORY,               /* file_attributes */
4557                 0,                                      /* oplock_request */
4558                 NULL,                                   /* lease */
4559                 0,                                      /* allocation_size */
4560                 0,                                      /* private_flags */
4561                 NULL,                                   /* sd */
4562                 NULL,                                   /* ea_list */
4563                 &fsp,                                   /* result */
4564                 NULL,                                   /* pinfo */
4565                 NULL, NULL);                            /* create context */
4566
4567         if (NT_STATUS_IS_OK(status)) {
4568                 close_file(req, fsp, NORMAL_CLOSE);
4569         }
4570
4571         return status;
4572 }
4573
4574 /****************************************************************************
4575  Receive notification that one of our open files has been renamed by another
4576  smbd process.
4577 ****************************************************************************/
4578
4579 void msg_file_was_renamed(struct messaging_context *msg_ctx,
4580                           void *private_data,
4581                           uint32_t msg_type,
4582                           struct server_id src,
4583                           DATA_BLOB *data)
4584 {
4585         struct file_rename_message *msg = NULL;
4586         enum ndr_err_code ndr_err;
4587         files_struct *fsp;
4588         struct smb_filename *smb_fname = NULL;
4589         struct smbd_server_connection *sconn =
4590                 talloc_get_type_abort(private_data,
4591                 struct smbd_server_connection);
4592
4593         msg = talloc(talloc_tos(), struct file_rename_message);
4594         if (msg == NULL) {
4595                 DBG_WARNING("talloc failed\n");
4596                 return;
4597         }
4598
4599         ndr_err = ndr_pull_struct_blob_all(
4600                 data,
4601                 msg,
4602                 msg,
4603                 (ndr_pull_flags_fn_t)ndr_pull_file_rename_message);
4604         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4605                 DBG_DEBUG("ndr_pull_oplock_break_message failed: %s\n",
4606                           ndr_errstr(ndr_err));
4607                 goto out;
4608         }
4609         if (DEBUGLEVEL >= 10) {
4610                 struct server_id_buf buf;
4611                 DBG_DEBUG("Got rename message from %s\n",
4612                           server_id_str_buf(src, &buf));
4613                 NDR_PRINT_DEBUG(file_rename_message, msg);
4614         }
4615
4616         /* stream_name must always be NULL if there is no stream. */
4617         if ((msg->stream_name != NULL) && (msg->stream_name[0] == '\0')) {
4618                 msg->stream_name = NULL;
4619         }
4620
4621         smb_fname = synthetic_smb_fname(
4622                 msg, msg->base_name, msg->stream_name, NULL, 0);
4623         if (smb_fname == NULL) {
4624                 DBG_DEBUG("synthetic_smb_fname failed\n");
4625                 goto out;
4626         }
4627
4628         fsp = file_find_dif(sconn, msg->id, msg->share_file_id);
4629         if (fsp == NULL) {
4630                 DBG_DEBUG("fsp not found\n");
4631                 goto out;
4632         }
4633
4634         if (strcmp(fsp->conn->connectpath, msg->servicepath) == 0) {
4635                 NTSTATUS status;
4636                 DBG_DEBUG("renaming file %s from %s -> %s\n",
4637                           fsp_fnum_dbg(fsp),
4638                           fsp_str_dbg(fsp),
4639                           smb_fname_str_dbg(smb_fname));
4640                 status = fsp_set_smb_fname(fsp, smb_fname);
4641                 if (!NT_STATUS_IS_OK(status)) {
4642                         DBG_DEBUG("fsp_set_smb_fname failed: %s\n",
4643                                   nt_errstr(status));
4644                 }
4645         } else {
4646                 /* TODO. JRA. */
4647                 /*
4648                  * Now we have the complete path we can work out if
4649                  * this is actually within this share and adjust
4650                  * newname accordingly.
4651                  */
4652                 DBG_DEBUG("share mismatch (sharepath %s not sharepath %s) "
4653                           "%s from %s -> %s\n",
4654                           fsp->conn->connectpath,
4655                           msg->servicepath,
4656                           fsp_fnum_dbg(fsp),
4657                           fsp_str_dbg(fsp),
4658                           smb_fname_str_dbg(smb_fname));
4659         }
4660  out:
4661         TALLOC_FREE(msg);
4662 }
4663
4664 /*
4665  * If a main file is opened for delete, all streams need to be checked for
4666  * !FILE_SHARE_DELETE. Do this by opening with DELETE_ACCESS.
4667  * If that works, delete them all by setting the delete on close and close.
4668  */
4669
4670 static NTSTATUS open_streams_for_delete(connection_struct *conn,
4671                                         const struct smb_filename *smb_fname)
4672 {
4673         struct stream_struct *stream_info = NULL;
4674         files_struct **streams = NULL;
4675         int j;
4676         unsigned int i, num_streams = 0;
4677         TALLOC_CTX *frame = talloc_stackframe();
4678         NTSTATUS status;
4679
4680         status = vfs_streaminfo(conn, NULL, smb_fname, talloc_tos(),
4681                                 &num_streams, &stream_info);
4682
4683         if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_IMPLEMENTED)
4684             || NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
4685                 DEBUG(10, ("no streams around\n"));
4686                 TALLOC_FREE(frame);
4687                 return NT_STATUS_OK;
4688         }
4689
4690         if (!NT_STATUS_IS_OK(status)) {
4691                 DEBUG(10, ("vfs_streaminfo failed: %s\n",
4692                            nt_errstr(status)));
4693                 goto fail;
4694         }
4695
4696         DEBUG(10, ("open_streams_for_delete found %d streams\n",
4697                    num_streams));
4698
4699         if (num_streams == 0) {
4700                 TALLOC_FREE(frame);
4701                 return NT_STATUS_OK;
4702         }
4703
4704         streams = talloc_array(talloc_tos(), files_struct *, num_streams);
4705         if (streams == NULL) {
4706                 DEBUG(0, ("talloc failed\n"));
4707                 status = NT_STATUS_NO_MEMORY;
4708                 goto fail;
4709         }
4710
4711         for (i=0; i<num_streams; i++) {
4712                 struct smb_filename *smb_fname_cp;
4713
4714                 if (strequal(stream_info[i].name, "::$DATA")) {
4715                         streams[i] = NULL;
4716                         continue;
4717                 }
4718
4719                 smb_fname_cp = synthetic_smb_fname(talloc_tos(),
4720                                         smb_fname->base_name,
4721                                         stream_info[i].name,
4722                                         NULL,
4723                                         (smb_fname->flags &
4724                                                 ~SMB_FILENAME_POSIX_PATH));
4725                 if (smb_fname_cp == NULL) {
4726                         status = NT_STATUS_NO_MEMORY;
4727                         goto fail;
4728                 }
4729
4730                 if (SMB_VFS_STAT(conn, smb_fname_cp) == -1) {
4731                         DEBUG(10, ("Unable to stat stream: %s\n",
4732                                    smb_fname_str_dbg(smb_fname_cp)));
4733                 }
4734
4735                 status = SMB_VFS_CREATE_FILE(
4736                          conn,                  /* conn */
4737                          NULL,                  /* req */
4738                          0,                     /* root_dir_fid */
4739                          smb_fname_cp,          /* fname */
4740                          DELETE_ACCESS,         /* access_mask */
4741                          (FILE_SHARE_READ |     /* share_access */
4742                              FILE_SHARE_WRITE | FILE_SHARE_DELETE),
4743                          FILE_OPEN,             /* create_disposition*/
4744                          0,                     /* create_options */
4745                          FILE_ATTRIBUTE_NORMAL, /* file_attributes */
4746                          0,                     /* oplock_request */
4747                          NULL,                  /* lease */
4748                          0,                     /* allocation_size */
4749                          NTCREATEX_OPTIONS_PRIVATE_STREAM_DELETE, /* private_flags */
4750                          NULL,                  /* sd */
4751                          NULL,                  /* ea_list */
4752                          &streams[i],           /* result */
4753                          NULL,                  /* pinfo */
4754                          NULL, NULL);           /* create context */
4755
4756                 if (!NT_STATUS_IS_OK(status)) {
4757                         DEBUG(10, ("Could not open stream %s: %s\n",
4758                                    smb_fname_str_dbg(smb_fname_cp),
4759                                    nt_errstr(status)));
4760
4761                         TALLOC_FREE(smb_fname_cp);
4762                         break;
4763                 }
4764                 TALLOC_FREE(smb_fname_cp);
4765         }
4766
4767         /*
4768          * don't touch the variable "status" beyond this point :-)
4769          */
4770
4771         for (j = i-1 ; j >= 0; j--) {
4772                 if (streams[j] == NULL) {
4773                         continue;
4774                 }
4775
4776                 DEBUG(10, ("Closing stream # %d, %s\n", j,
4777                            fsp_str_dbg(streams[j])));
4778                 close_file(NULL, streams[j], NORMAL_CLOSE);
4779         }
4780
4781  fail:
4782         TALLOC_FREE(frame);
4783         return status;
4784 }
4785
4786 /*********************************************************************
4787  Create a default ACL by inheriting from the parent. If no inheritance
4788  from the parent available, don't set anything. This will leave the actual
4789  permissions the new file or directory already got from the filesystem
4790  as the NT ACL when read.
4791 *********************************************************************/
4792
4793 static NTSTATUS inherit_new_acl(files_struct *fsp)
4794 {
4795         TALLOC_CTX *frame = talloc_stackframe();
4796         char *parent_name = NULL;
4797         struct security_descriptor *parent_desc = NULL;
4798         NTSTATUS status = NT_STATUS_OK;
4799         struct security_descriptor *psd = NULL;
4800         const struct dom_sid *owner_sid = NULL;
4801         const struct dom_sid *group_sid = NULL;
4802         uint32_t security_info_sent = (SECINFO_OWNER | SECINFO_GROUP | SECINFO_DACL);
4803         struct security_token *token = fsp->conn->session_info->security_token;
4804         bool inherit_owner =
4805             (lp_inherit_owner(SNUM(fsp->conn)) == INHERIT_OWNER_WINDOWS_AND_UNIX);
4806         bool inheritable_components = false;
4807         bool try_builtin_administrators = false;
4808         const struct dom_sid *BA_U_sid = NULL;
4809         const struct dom_sid *BA_G_sid = NULL;
4810         bool try_system = false;
4811         const struct dom_sid *SY_U_sid = NULL;
4812         const struct dom_sid *SY_G_sid = NULL;
4813         size_t size = 0;
4814         struct smb_filename *parent_smb_fname = NULL;
4815
4816         if (!parent_dirname(frame, fsp->fsp_name->base_name, &parent_name, NULL)) {
4817                 TALLOC_FREE(frame);
4818                 return NT_STATUS_NO_MEMORY;
4819         }
4820         parent_smb_fname = synthetic_smb_fname(talloc_tos(),
4821                                                 parent_name,
4822                                                 NULL,
4823                                                 NULL,
4824                                                 fsp->fsp_name->flags);
4825
4826         if (parent_smb_fname == NULL) {
4827                 TALLOC_FREE(frame);
4828                 return NT_STATUS_NO_MEMORY;
4829         }
4830
4831         status = SMB_VFS_GET_NT_ACL(fsp->conn,
4832                                     parent_smb_fname,
4833                                     (SECINFO_OWNER | SECINFO_GROUP | SECINFO_DACL),
4834                                     frame,
4835                                     &parent_desc);
4836         if (!NT_STATUS_IS_OK(status)) {
4837                 TALLOC_FREE(frame);
4838                 return status;
4839         }
4840
4841         inheritable_components = sd_has_inheritable_components(parent_desc,
4842                                         fsp->is_directory);
4843
4844         if (!inheritable_components && !inherit_owner) {
4845                 TALLOC_FREE(frame);
4846                 /* Nothing to inherit and not setting owner. */
4847                 return NT_STATUS_OK;
4848         }
4849
4850         /* Create an inherited descriptor from the parent. */
4851
4852         if (DEBUGLEVEL >= 10) {
4853                 DEBUG(10,("inherit_new_acl: parent acl for %s is:\n",
4854                         fsp_str_dbg(fsp) ));
4855                 NDR_PRINT_DEBUG(security_descriptor, parent_desc);
4856         }
4857
4858         /* Inherit from parent descriptor if "inherit owner" set. */
4859         if (inherit_owner) {
4860                 owner_sid = parent_desc->owner_sid;
4861                 group_sid = parent_desc->group_sid;
4862         }
4863
4864         if (owner_sid == NULL) {
4865                 if (security_token_has_builtin_administrators(token)) {
4866                         try_builtin_administrators = true;
4867                 } else if (security_token_is_system(token)) {
4868                         try_builtin_administrators = true;
4869                         try_system = true;
4870                 }
4871         }
4872
4873         if (group_sid == NULL &&
4874             token->num_sids == PRIMARY_GROUP_SID_INDEX)
4875         {
4876                 if (security_token_is_system(token)) {
4877                         try_builtin_administrators = true;
4878                         try_system = true;
4879                 }
4880         }
4881
4882         if (try_builtin_administrators) {
4883                 struct unixid ids;
4884                 bool ok;
4885
4886                 ZERO_STRUCT(ids);
4887                 ok = sids_to_unixids(&global_sid_Builtin_Administrators, 1, &ids);
4888                 if (ok) {
4889                         switch (ids.type) {
4890                         case ID_TYPE_BOTH:
4891                                 BA_U_sid = &global_sid_Builtin_Administrators;
4892                                 BA_G_sid = &global_sid_Builtin_Administrators;
4893                                 break;
4894                         case ID_TYPE_UID:
4895                                 BA_U_sid = &global_sid_Builtin_Administrators;
4896                                 break;
4897                         case ID_TYPE_GID:
4898                                 BA_G_sid = &global_sid_Builtin_Administrators;
4899                                 break;
4900                         default:
4901                                 break;
4902                         }
4903                 }
4904         }
4905
4906         if (try_system) {
4907                 struct unixid ids;
4908                 bool ok;
4909
4910                 ZERO_STRUCT(ids);
4911                 ok = sids_to_unixids(&global_sid_System, 1, &ids);
4912                 if (ok) {
4913                         switch (ids.type) {
4914                         case ID_TYPE_BOTH:
4915                                 SY_U_sid = &global_sid_System;
4916                                 SY_G_sid = &global_sid_System;
4917                                 break;
4918                         case ID_TYPE_UID:
4919                                 SY_U_sid = &global_sid_System;
4920                                 break;
4921                         case ID_TYPE_GID:
4922                                 SY_G_sid = &global_sid_System;
4923                                 break;
4924                         default:
4925                                 break;
4926                         }
4927                 }
4928         }
4929
4930         if (owner_sid == NULL) {
4931                 owner_sid = BA_U_sid;
4932         }
4933
4934         if (owner_sid == NULL) {
4935                 owner_sid = SY_U_sid;
4936         }
4937
4938         if (group_sid == NULL) {
4939                 group_sid = SY_G_sid;
4940         }
4941
4942         if (try_system && group_sid == NULL) {
4943                 group_sid = BA_G_sid;
4944         }
4945
4946         if (owner_sid == NULL) {
4947                 owner_sid = &token->sids[PRIMARY_USER_SID_INDEX];
4948         }
4949         if (group_sid == NULL) {
4950                 if (token->num_sids == PRIMARY_GROUP_SID_INDEX) {
4951                         group_sid = &token->sids[PRIMARY_USER_SID_INDEX];
4952                 } else {
4953                         group_sid = &token->sids[PRIMARY_GROUP_SID_INDEX];
4954                 }
4955         }
4956
4957         status = se_create_child_secdesc(frame,
4958                         &psd,
4959                         &size,
4960                         parent_desc,
4961                         owner_sid,
4962                         group_sid,
4963                         fsp->is_directory);
4964         if (!NT_STATUS_IS_OK(status)) {
4965                 TALLOC_FREE(frame);
4966                 return status;
4967         }
4968
4969         /* If inheritable_components == false,
4970            se_create_child_secdesc()
4971            creates a security descriptor with a NULL dacl
4972            entry, but with SEC_DESC_DACL_PRESENT. We need
4973            to remove that flag. */
4974
4975         if (!inheritable_components) {
4976                 security_info_sent &= ~SECINFO_DACL;
4977                 psd->type &= ~SEC_DESC_DACL_PRESENT;
4978         }
4979
4980         if (DEBUGLEVEL >= 10) {
4981                 DEBUG(10,("inherit_new_acl: child acl for %s is:\n",
4982                         fsp_str_dbg(fsp) ));
4983                 NDR_PRINT_DEBUG(security_descriptor, psd);
4984         }
4985
4986         if (inherit_owner) {
4987                 /* We need to be root to force this. */
4988                 become_root();
4989         }
4990         status = SMB_VFS_FSET_NT_ACL(fsp,
4991                         security_info_sent,
4992                         psd);
4993         if (inherit_owner) {
4994                 unbecome_root();
4995         }
4996         TALLOC_FREE(frame);
4997         return status;
4998 }
4999
5000 /*
5001  * If we already have a lease, it must match the new file id. [MS-SMB2]
5002  * 3.3.5.9.8 speaks about INVALID_PARAMETER if an already used lease key is
5003  * used for a different file name.
5004  */
5005
5006 struct lease_match_state {
5007         /* Input parameters. */
5008         TALLOC_CTX *mem_ctx;
5009         const char *servicepath;
5010         const struct smb_filename *fname;
5011         bool file_existed;
5012         struct file_id id;
5013         /* Return parameters. */
5014         uint32_t num_file_ids;
5015         struct file_id *ids;
5016         NTSTATUS match_status;
5017 };
5018
5019 /*************************************************************
5020  File doesn't exist but this lease key+guid is already in use.
5021
5022  This is only allowable in the dynamic share case where the
5023  service path must be different.
5024
5025  There is a small race condition here in the multi-connection
5026  case where a client sends two create calls on different connections,
5027  where the file doesn't exist and one smbd creates the leases_db
5028  entry first, but this will get fixed by the multichannel cleanup
5029  when all identical client_guids get handled by a single smbd.
5030 **************************************************************/
5031
5032 static void lease_match_parser_new_file(
5033         uint32_t num_files,
5034         const struct leases_db_file *files,
5035         struct lease_match_state *state)
5036 {
5037         uint32_t i;
5038
5039         for (i = 0; i < num_files; i++) {
5040                 const struct leases_db_file *f = &files[i];
5041                 if (strequal(state->servicepath, f->servicepath)) {
5042                         state->match_status = NT_STATUS_INVALID_PARAMETER;
5043                         return;
5044                 }
5045         }
5046
5047         /* Dynamic share case. Break leases on all other files. */
5048         state->match_status = leases_db_copy_file_ids(state->mem_ctx,
5049                                         num_files,
5050                                         files,
5051                                         &state->ids);
5052         if (!NT_STATUS_IS_OK(state->match_status)) {
5053                 return;
5054         }
5055
5056         state->num_file_ids = num_files;
5057         state->match_status = NT_STATUS_OPLOCK_NOT_GRANTED;
5058         return;
5059 }
5060
5061 static void lease_match_parser(
5062         uint32_t num_files,
5063         const struct leases_db_file *files,
5064         void *private_data)
5065 {
5066         struct lease_match_state *state =
5067                 (struct lease_match_state *)private_data;
5068         uint32_t i;
5069
5070         if (!state->file_existed) {
5071                 /*
5072                  * Deal with name mismatch or
5073                  * possible dynamic share case separately
5074                  * to make code clearer.
5075                  */
5076                 lease_match_parser_new_file(num_files,
5077                                                 files,
5078                                                 state);
5079                 return;
5080         }
5081
5082         /* File existed. */
5083         state->match_status = NT_STATUS_OK;
5084
5085         for (i = 0; i < num_files; i++) {
5086                 const struct leases_db_file *f = &files[i];
5087
5088                 /* Everything should be the same. */
5089                 if (!file_id_equal(&state->id, &f->id)) {
5090                         /* This should catch all dynamic share cases. */
5091                         state->match_status = NT_STATUS_OPLOCK_NOT_GRANTED;
5092                         break;
5093                 }
5094                 if (!strequal(f->servicepath, state->servicepath)) {
5095                         state->match_status = NT_STATUS_INVALID_PARAMETER;
5096                         break;
5097                 }
5098                 if (!strequal(f->base_name, state->fname->base_name)) {
5099                         state->match_status = NT_STATUS_INVALID_PARAMETER;
5100                         break;
5101                 }
5102                 if (!strequal(f->stream_name, state->fname->stream_name)) {
5103                         state->match_status = NT_STATUS_INVALID_PARAMETER;
5104                         break;
5105                 }
5106         }
5107
5108         if (NT_STATUS_IS_OK(state->match_status)) {
5109                 /*
5110                  * Common case - just opening another handle on a
5111                  * file on a non-dynamic share.
5112                  */
5113                 return;
5114         }
5115
5116         if (NT_STATUS_EQUAL(state->match_status, NT_STATUS_INVALID_PARAMETER)) {
5117                 /* Mismatched path. Error back to client. */
5118                 return;
5119         }
5120
5121         /*
5122          * File id mismatch. Dynamic share case NT_STATUS_OPLOCK_NOT_GRANTED.
5123          * Don't allow leases.
5124          */
5125
5126         state->match_status = leases_db_copy_file_ids(state->mem_ctx,
5127                                         num_files,
5128                                         files,
5129                                         &state->ids);
5130         if (!NT_STATUS_IS_OK(state->match_status)) {
5131                 return;
5132         }
5133
5134         state->num_file_ids = num_files;
5135         state->match_status = NT_STATUS_OPLOCK_NOT_GRANTED;
5136         return;
5137 }
5138
5139 struct lease_match_break_state {
5140         struct messaging_context *msg_ctx;
5141         const struct smb2_lease_key *lease_key;
5142         struct file_id id;
5143
5144         bool found_lease;
5145         uint16_t version;
5146         uint16_t epoch;
5147 };
5148
5149 static bool lease_match_break_fn(
5150         struct share_mode_entry *e,
5151         void *private_data)
5152 {
5153         struct lease_match_break_state *state = private_data;
5154         bool stale, equal;
5155         uint32_t e_lease_type;
5156         NTSTATUS status;
5157
5158         stale = share_entry_stale_pid(e);
5159         if (stale) {
5160                 return false;
5161         }
5162
5163         equal = smb2_lease_key_equal(&e->lease_key, state->lease_key);
5164         if (!equal) {
5165                 return false;
5166         }
5167
5168         status = leases_db_get(
5169                 &e->client_guid,
5170                 &e->lease_key,
5171                 &state->id,
5172                 NULL, /* current_state */
5173                 NULL, /* breaking */
5174                 NULL, /* breaking_to_requested */
5175                 NULL, /* breaking_to_required */
5176                 &state->version, /* lease_version */
5177                 &state->epoch); /* epoch */
5178         if (NT_STATUS_IS_OK(status)) {
5179                 state->found_lease = true;
5180         } else {
5181                 DBG_WARNING("Could not find version/epoch: %s\n",
5182                             nt_errstr(status));
5183         }
5184
5185         e_lease_type = get_lease_type(e, state->id);
5186         if (e_lease_type == SMB2_LEASE_NONE) {
5187                 return false;
5188         }
5189         send_break_message(state->msg_ctx, &state->id, e, SMB2_LEASE_NONE);
5190
5191         /*
5192          * Windows 7 and 8 lease clients are broken in that they will
5193          * not respond to lease break requests whilst waiting for an
5194          * outstanding open request on that lease handle on the same
5195          * TCP connection, due to holding an internal inode lock.
5196          *
5197          * This means we can't reschedule ourselves here, but must
5198          * return from the create.
5199          *
5200          * Work around:
5201          *
5202          * Send the breaks and then return SMB2_LEASE_NONE in the
5203          * lease handle to cause them to acknowledge the lease
5204          * break. Consultation with Microsoft engineering confirmed
5205          * this approach is safe.
5206          */
5207
5208         return false;
5209 }
5210
5211 static NTSTATUS lease_match(connection_struct *conn,
5212                             struct smb_request *req,
5213                             const struct smb2_lease_key *lease_key,
5214                             const char *servicepath,
5215                             const struct smb_filename *fname,
5216                             uint16_t *p_version,
5217                             uint16_t *p_epoch)
5218 {
5219         struct smbd_server_connection *sconn = req->sconn;
5220         TALLOC_CTX *tos = talloc_tos();
5221         struct lease_match_state state = {
5222                 .mem_ctx = tos,
5223                 .servicepath = servicepath,
5224                 .fname = fname,
5225                 .match_status = NT_STATUS_OK
5226         };
5227         uint32_t i;
5228         NTSTATUS status;
5229
5230         state.file_existed = VALID_STAT(fname->st);
5231         if (state.file_existed) {
5232                 state.id = vfs_file_id_from_sbuf(conn, &fname->st);
5233         }
5234
5235         status = leases_db_parse(&sconn->client->connections->smb2.client.guid,
5236                                  lease_key, lease_match_parser, &state);
5237         if (!NT_STATUS_IS_OK(status)) {
5238                 /*
5239                  * Not found or error means okay: We can make the lease pass
5240                  */
5241                 return NT_STATUS_OK;
5242         }
5243         if (!NT_STATUS_EQUAL(state.match_status, NT_STATUS_OPLOCK_NOT_GRANTED)) {
5244                 /*
5245                  * Anything but NT_STATUS_OPLOCK_NOT_GRANTED, let the caller
5246                  * deal with it.
5247                  */
5248                 return state.match_status;
5249         }
5250
5251         /* We have to break all existing leases. */
5252         for (i = 0; i < state.num_file_ids; i++) {
5253                 struct lease_match_break_state break_state = {
5254                         .msg_ctx = conn->sconn->msg_ctx,
5255                         .lease_key = lease_key,
5256                 };
5257                 struct share_mode_lock *lck;
5258                 bool ok;
5259
5260                 if (file_id_equal(&state.ids[i], &state.id)) {
5261                         /* Don't need to break our own file. */
5262                         continue;
5263                 }
5264
5265                 break_state.id = state.ids[i];
5266
5267                 lck = get_existing_share_mode_lock(
5268                         talloc_tos(), break_state.id);
5269                 if (lck == NULL) {
5270                         /* Race condition - file already closed. */
5271                         continue;
5272                 }
5273
5274                 ok = share_mode_forall_leases(
5275                         lck, lease_match_break_fn, &break_state);
5276                 if (!ok) {
5277                         DBG_DEBUG("share_mode_forall_leases failed\n");
5278                         continue;
5279                 }
5280
5281                 TALLOC_FREE(lck);
5282
5283                 if (break_state.found_lease) {
5284                         *p_version = break_state.version;
5285                         *p_epoch = break_state.epoch;
5286                 }
5287         }
5288         /*
5289          * Ensure we don't grant anything more so we
5290          * never upgrade.
5291          */
5292         return NT_STATUS_OPLOCK_NOT_GRANTED;
5293 }
5294
5295 /*
5296  * Wrapper around open_file_ntcreate and open_directory
5297  */
5298
5299 static NTSTATUS create_file_unixpath(connection_struct *conn,
5300                                      struct smb_request *req,
5301                                      struct smb_filename *smb_fname,
5302                                      uint32_t access_mask,
5303                                      uint32_t share_access,
5304                                      uint32_t create_disposition,
5305                                      uint32_t create_options,
5306                                      uint32_t file_attributes,
5307                                      uint32_t oplock_request,
5308                                      const struct smb2_lease *lease,
5309                                      uint64_t allocation_size,
5310                                      uint32_t private_flags,
5311                                      struct security_descriptor *sd,
5312                                      struct ea_list *ea_list,
5313
5314                                      files_struct **result,
5315                                      int *pinfo)
5316 {
5317         struct smb2_lease none_lease;
5318         int info = FILE_WAS_OPENED;
5319         files_struct *base_fsp = NULL;
5320         files_struct *fsp = NULL;
5321         NTSTATUS status;
5322
5323         DBG_DEBUG("create_file_unixpath: access_mask = 0x%x "
5324                   "file_attributes = 0x%x, share_access = 0x%x, "
5325                   "create_disposition = 0x%x create_options = 0x%x "
5326                   "oplock_request = 0x%x private_flags = 0x%x "
5327                   "ea_list = %p, sd = %p, "
5328                   "fname = %s\n",
5329                   (unsigned int)access_mask,
5330                   (unsigned int)file_attributes,
5331                   (unsigned int)share_access,
5332                   (unsigned int)create_disposition,
5333                   (unsigned int)create_options,
5334                   (unsigned int)oplock_request,
5335                   (unsigned int)private_flags,
5336                   ea_list, sd, smb_fname_str_dbg(smb_fname));
5337
5338         if (create_options & FILE_OPEN_BY_FILE_ID) {
5339                 status = NT_STATUS_NOT_SUPPORTED;
5340                 goto fail;
5341         }
5342
5343         if (create_options & NTCREATEX_OPTIONS_INVALID_PARAM_MASK) {
5344                 status = NT_STATUS_INVALID_PARAMETER;
5345                 goto fail;
5346         }
5347
5348         if (req == NULL) {
5349                 oplock_request |= INTERNAL_OPEN_ONLY;
5350         }
5351
5352         if (lease != NULL) {
5353                 uint16_t epoch = lease->lease_epoch;
5354                 uint16_t version = lease->lease_version;
5355
5356                 if (req == NULL) {
5357                         DBG_WARNING("Got lease on internal open\n");
5358                         status = NT_STATUS_INTERNAL_ERROR;
5359                         goto fail;
5360                 }
5361
5362                 status = lease_match(conn,
5363                                 req,
5364                                 &lease->lease_key,
5365                                 conn->connectpath,
5366                                 smb_fname,
5367                                 &version,
5368                                 &epoch);
5369                 if (NT_STATUS_EQUAL(status, NT_STATUS_OPLOCK_NOT_GRANTED)) {
5370                         /* Dynamic share file. No leases and update epoch... */
5371                         none_lease = *lease;
5372                         none_lease.lease_state = SMB2_LEASE_NONE;
5373                         none_lease.lease_epoch = epoch;
5374                         none_lease.lease_version = version;
5375                         lease = &none_lease;
5376                 } else if (!NT_STATUS_IS_OK(status)) {
5377                         goto fail;
5378                 }
5379         }
5380
5381         if ((conn->fs_capabilities & FILE_NAMED_STREAMS)
5382             && (access_mask & DELETE_ACCESS)
5383             && !is_ntfs_stream_smb_fname(smb_fname)) {
5384                 /*
5385                  * We can't open a file with DELETE access if any of the
5386                  * streams is open without FILE_SHARE_DELETE
5387                  */
5388                 status = open_streams_for_delete(conn, smb_fname);
5389
5390                 if (!NT_STATUS_IS_OK(status)) {
5391                         goto fail;
5392                 }
5393         }
5394
5395         if ((access_mask & SEC_FLAG_SYSTEM_SECURITY) &&
5396                         !security_token_has_privilege(get_current_nttok(conn),
5397                                         SEC_PRIV_SECURITY)) {
5398                 DEBUG(10, ("create_file_unixpath: open on %s "
5399                         "failed - SEC_FLAG_SYSTEM_SECURITY denied.\n",
5400                         smb_fname_str_dbg(smb_fname)));
5401                 status = NT_STATUS_PRIVILEGE_NOT_HELD;
5402                 goto fail;
5403         }
5404
5405         /*
5406          * Files or directories can't be opened DELETE_ON_CLOSE without
5407          * delete access.
5408          * BUG: https://bugzilla.samba.org/show_bug.cgi?id=13358
5409          */
5410         if (create_options & FILE_DELETE_ON_CLOSE) {
5411                 if ((access_mask & DELETE_ACCESS) == 0) {
5412                         status = NT_STATUS_INVALID_PARAMETER;
5413                         goto fail;
5414                 }
5415         }
5416
5417         if ((conn->fs_capabilities & FILE_NAMED_STREAMS)
5418             && is_ntfs_stream_smb_fname(smb_fname)
5419             && (!(private_flags & NTCREATEX_OPTIONS_PRIVATE_STREAM_DELETE))) {
5420                 uint32_t base_create_disposition;
5421                 struct smb_filename *smb_fname_base = NULL;
5422                 uint32_t base_privflags;
5423
5424                 if (create_options & FILE_DIRECTORY_FILE) {
5425                         status = NT_STATUS_NOT_A_DIRECTORY;
5426                         goto fail;
5427                 }
5428
5429                 switch (create_disposition) {
5430                 case FILE_OPEN:
5431                         base_create_disposition = FILE_OPEN;
5432                         break;
5433                 default:
5434                         base_create_disposition = FILE_OPEN_IF;
5435                         break;
5436                 }
5437
5438                 /* Create an smb_filename with stream_name == NULL. */
5439                 smb_fname_base = synthetic_smb_fname(talloc_tos(),
5440                                                 smb_fname->base_name,
5441                                                 NULL,
5442                                                 NULL,
5443                                                 smb_fname->flags);
5444                 if (smb_fname_base == NULL) {
5445                         status = NT_STATUS_NO_MEMORY;
5446                         goto fail;
5447                 }
5448
5449                 if (SMB_VFS_STAT(conn, smb_fname_base) == -1) {
5450                         DEBUG(10, ("Unable to stat stream: %s\n",
5451                                    smb_fname_str_dbg(smb_fname_base)));
5452                 } else {
5453                         /*
5454                          * https://bugzilla.samba.org/show_bug.cgi?id=10229
5455                          * We need to check if the requested access mask
5456                          * could be used to open the underlying file (if
5457                          * it existed), as we're passing in zero for the
5458                          * access mask to the base filename.
5459                          */
5460                         status = check_base_file_access(conn,
5461                                                         smb_fname_base,
5462                                                         access_mask);
5463
5464                         if (!NT_STATUS_IS_OK(status)) {
5465                                 DEBUG(10, ("Permission check "
5466                                         "for base %s failed: "
5467                                         "%s\n", smb_fname->base_name,
5468                                         nt_errstr(status)));
5469                                 goto fail;
5470                         }
5471                 }
5472
5473                 base_privflags = NTCREATEX_OPTIONS_PRIVATE_STREAM_BASEOPEN;
5474
5475                 /* Open the base file. */
5476                 status = create_file_unixpath(conn, NULL, smb_fname_base, 0,
5477                                               FILE_SHARE_READ
5478                                               | FILE_SHARE_WRITE
5479                                               | FILE_SHARE_DELETE,
5480                                               base_create_disposition,
5481                                               0, 0, 0, NULL, 0,
5482                                               base_privflags,
5483                                               NULL, NULL,
5484                                               &base_fsp, NULL);
5485                 TALLOC_FREE(smb_fname_base);
5486
5487                 if (!NT_STATUS_IS_OK(status)) {
5488                         DEBUG(10, ("create_file_unixpath for base %s failed: "
5489                                    "%s\n", smb_fname->base_name,
5490                                    nt_errstr(status)));
5491                         goto fail;
5492                 }
5493                 /* we don't need the low level fd */
5494                 fd_close(base_fsp);
5495         }
5496
5497         /*
5498          * If it's a request for a directory open, deal with it separately.
5499          */
5500
5501         if (create_options & FILE_DIRECTORY_FILE) {
5502
5503                 if (create_options & FILE_NON_DIRECTORY_FILE) {
5504                         status = NT_STATUS_INVALID_PARAMETER;
5505                         goto fail;
5506                 }
5507
5508                 /* Can't open a temp directory. IFS kit test. */
5509                 if (!(file_attributes & FILE_FLAG_POSIX_SEMANTICS) &&
5510                      (file_attributes & FILE_ATTRIBUTE_TEMPORARY)) {
5511                         status = NT_STATUS_INVALID_PARAMETER;
5512                         goto fail;
5513                 }
5514
5515                 /*
5516                  * We will get a create directory here if the Win32
5517                  * app specified a security descriptor in the
5518                  * CreateDirectory() call.
5519                  */
5520
5521                 oplock_request = 0;
5522                 status = open_directory(
5523                         conn, req, smb_fname, access_mask, share_access,
5524                         create_disposition, create_options, file_attributes,
5525                         &info, &fsp);
5526         } else {
5527
5528                 /*
5529                  * Ordinary file case.
5530                  */
5531
5532                 status = file_new(req, conn, &fsp);
5533                 if(!NT_STATUS_IS_OK(status)) {
5534                         goto fail;
5535                 }
5536
5537                 status = fsp_set_smb_fname(fsp, smb_fname);
5538                 if (!NT_STATUS_IS_OK(status)) {
5539                         goto fail;
5540                 }
5541
5542                 if (base_fsp) {
5543                         /*
5544                          * We're opening the stream element of a
5545                          * base_fsp we already opened. Set up the
5546                          * base_fsp pointer.
5547                          */
5548                         fsp->base_fsp = base_fsp;
5549                 }
5550
5551                 if (allocation_size) {
5552                         fsp->initial_allocation_size = smb_roundup(fsp->conn,
5553                                                         allocation_size);
5554                 }
5555
5556                 status = open_file_ntcreate(conn,
5557                                             req,
5558                                             access_mask,
5559                                             share_access,
5560                                             create_disposition,
5561                                             create_options,
5562                                             file_attributes,
5563                                             oplock_request,
5564                                             lease,
5565                                             private_flags,
5566                                             &info,
5567                                             fsp);
5568
5569                 if(!NT_STATUS_IS_OK(status)) {
5570                         file_free(req, fsp);
5571                         fsp = NULL;
5572                 }
5573
5574                 if (NT_STATUS_EQUAL(status, NT_STATUS_FILE_IS_A_DIRECTORY)) {
5575
5576                         /* A stream open never opens a directory */
5577
5578                         if (base_fsp) {
5579                                 status = NT_STATUS_FILE_IS_A_DIRECTORY;
5580                                 goto fail;
5581                         }
5582
5583                         /*
5584                          * Fail the open if it was explicitly a non-directory
5585                          * file.
5586                          */
5587
5588                         if (create_options & FILE_NON_DIRECTORY_FILE) {
5589                                 status = NT_STATUS_FILE_IS_A_DIRECTORY;
5590                                 goto fail;
5591                         }
5592
5593                         oplock_request = 0;
5594                         status = open_directory(
5595                                 conn, req, smb_fname, access_mask,
5596                                 share_access, create_disposition,
5597                                 create_options, file_attributes,
5598                                 &info, &fsp);
5599                 }
5600         }
5601
5602         if (!NT_STATUS_IS_OK(status)) {
5603                 goto fail;
5604         }
5605
5606         fsp->base_fsp = base_fsp;
5607
5608         if ((ea_list != NULL) &&
5609             ((info == FILE_WAS_CREATED) || (info == FILE_WAS_OVERWRITTEN))) {
5610                 status = set_ea(conn, fsp, fsp->fsp_name, ea_list);
5611                 if (!NT_STATUS_IS_OK(status)) {
5612                         goto fail;
5613                 }
5614         }
5615
5616         if (!fsp->is_directory && S_ISDIR(fsp->fsp_name->st.st_ex_mode)) {
5617                 status = NT_STATUS_ACCESS_DENIED;
5618                 goto fail;
5619         }
5620
5621         /* Save the requested allocation size. */
5622         if ((info == FILE_WAS_CREATED) || (info == FILE_WAS_OVERWRITTEN)) {
5623                 if ((allocation_size > (uint64_t)fsp->fsp_name->st.st_ex_size)
5624                     && !(fsp->is_directory))
5625                 {
5626                         fsp->initial_allocation_size = smb_roundup(
5627                                 fsp->conn, allocation_size);
5628                         if (vfs_allocate_file_space(
5629                                     fsp, fsp->initial_allocation_size) == -1) {
5630                                 status = NT_STATUS_DISK_FULL;
5631                                 goto fail;
5632                         }
5633                 } else {
5634                         fsp->initial_allocation_size = smb_roundup(
5635                                 fsp->conn, (uint64_t)fsp->fsp_name->st.st_ex_size);
5636                 }
5637         } else {
5638                 fsp->initial_allocation_size = 0;
5639         }
5640
5641         if ((info == FILE_WAS_CREATED) && lp_nt_acl_support(SNUM(conn)) &&
5642                                 fsp->base_fsp == NULL) {
5643                 if (sd != NULL) {
5644                         /*
5645                          * According to the MS documentation, the only time the security
5646                          * descriptor is applied to the opened file is iff we *created* the
5647                          * file; an existing file stays the same.
5648                          *
5649                          * Also, it seems (from observation) that you can open the file with
5650                          * any access mask but you can still write the sd. We need to override
5651                          * the granted access before we call set_sd
5652                          * Patch for bug #2242 from Tom Lackemann <cessnatomny@yahoo.com>.
5653                          */
5654
5655                         uint32_t sec_info_sent;
5656                         uint32_t saved_access_mask = fsp->access_mask;
5657
5658                         sec_info_sent = get_sec_info(sd);
5659
5660                         fsp->access_mask = FILE_GENERIC_ALL;
5661
5662                         if (sec_info_sent & (SECINFO_OWNER|
5663                                                 SECINFO_GROUP|
5664                                                 SECINFO_DACL|
5665                                                 SECINFO_SACL)) {
5666                                 status = set_sd(fsp, sd, sec_info_sent);
5667                         }
5668
5669                         fsp->access_mask = saved_access_mask;
5670
5671                         if (!NT_STATUS_IS_OK(status)) {
5672                                 goto fail;
5673                         }
5674                 } else if (lp_inherit_acls(SNUM(conn))) {
5675                         /* Inherit from parent. Errors here are not fatal. */
5676                         status = inherit_new_acl(fsp);
5677                         if (!NT_STATUS_IS_OK(status)) {
5678                                 DEBUG(10,("inherit_new_acl: failed for %s with %s\n",
5679                                         fsp_str_dbg(fsp),
5680                                         nt_errstr(status) ));
5681                         }
5682                 }
5683         }
5684
5685         if ((conn->fs_capabilities & FILE_FILE_COMPRESSION)
5686          && (create_options & FILE_NO_COMPRESSION)
5687          && (info == FILE_WAS_CREATED)) {
5688                 status = SMB_VFS_SET_COMPRESSION(conn, fsp, fsp,
5689                                                  COMPRESSION_FORMAT_NONE);
5690                 if (!NT_STATUS_IS_OK(status)) {
5691                         DEBUG(1, ("failed to disable compression: %s\n",
5692                                   nt_errstr(status)));
5693                 }
5694         }
5695
5696         DEBUG(10, ("create_file_unixpath: info=%d\n", info));
5697
5698         *result = fsp;
5699         if (pinfo != NULL) {
5700                 *pinfo = info;
5701         }
5702
5703         smb_fname->st = fsp->fsp_name->st;
5704
5705         return NT_STATUS_OK;
5706
5707  fail:
5708         DEBUG(10, ("create_file_unixpath: %s\n", nt_errstr(status)));
5709
5710         if (fsp != NULL) {
5711                 if (base_fsp && fsp->base_fsp == base_fsp) {
5712                         /*
5713                          * The close_file below will close
5714                          * fsp->base_fsp.
5715                          */
5716                         base_fsp = NULL;
5717                 }
5718                 close_file(req, fsp, ERROR_CLOSE);
5719                 fsp = NULL;
5720         }
5721         if (base_fsp != NULL) {
5722                 close_file(req, base_fsp, ERROR_CLOSE);
5723                 base_fsp = NULL;
5724         }
5725         return status;
5726 }
5727
5728 /*
5729  * Calculate the full path name given a relative fid.
5730  */
5731 static NTSTATUS get_relative_fid_filename(
5732         connection_struct *conn,
5733         struct smb_request *req,
5734         uint16_t root_dir_fid,
5735         const struct smb_filename *smb_fname,
5736         struct smb_filename **smb_fname_out)
5737 {
5738         files_struct *dir_fsp;
5739         char *parent_fname = NULL;
5740         char *new_base_name = NULL;
5741         uint32_t ucf_flags = ucf_flags_from_smb_request(req);
5742         NTSTATUS status;
5743
5744         if (root_dir_fid == 0 || !smb_fname) {
5745                 status = NT_STATUS_INTERNAL_ERROR;
5746                 goto out;
5747         }
5748
5749         dir_fsp = file_fsp(req, root_dir_fid);
5750
5751         if (dir_fsp == NULL) {
5752                 status = NT_STATUS_INVALID_HANDLE;
5753                 goto out;
5754         }
5755
5756         if (is_ntfs_stream_smb_fname(dir_fsp->fsp_name)) {
5757                 status = NT_STATUS_INVALID_HANDLE;
5758                 goto out;
5759         }
5760
5761         if (!dir_fsp->is_directory) {
5762
5763                 /*
5764                  * Check to see if this is a mac fork of some kind.
5765                  */
5766
5767                 if ((conn->fs_capabilities & FILE_NAMED_STREAMS) &&
5768                     is_ntfs_stream_smb_fname(smb_fname)) {
5769                         status = NT_STATUS_OBJECT_PATH_NOT_FOUND;
5770                         goto out;
5771                 }
5772
5773                 /*
5774                   we need to handle the case when we get a
5775                   relative open relative to a file and the
5776                   pathname is blank - this is a reopen!
5777                   (hint from demyn plantenberg)
5778                 */
5779
5780                 status = NT_STATUS_INVALID_HANDLE;
5781                 goto out;
5782         }
5783
5784         if (ISDOT(dir_fsp->fsp_name->base_name)) {
5785                 /*
5786                  * We're at the toplevel dir, the final file name
5787                  * must not contain ./, as this is filtered out
5788                  * normally by srvstr_get_path and unix_convert
5789                  * explicitly rejects paths containing ./.
5790                  */
5791                 parent_fname = talloc_strdup(talloc_tos(), "");
5792                 if (parent_fname == NULL) {
5793                         status = NT_STATUS_NO_MEMORY;
5794                         goto out;
5795                 }
5796         } else {
5797                 size_t dir_name_len = strlen(dir_fsp->fsp_name->base_name);
5798
5799                 /*
5800                  * Copy in the base directory name.
5801                  */
5802
5803                 parent_fname = talloc_array(talloc_tos(), char,
5804                     dir_name_len+2);
5805                 if (parent_fname == NULL) {
5806                         status = NT_STATUS_NO_MEMORY;
5807                         goto out;
5808                 }
5809                 memcpy(parent_fname, dir_fsp->fsp_name->base_name,
5810                     dir_name_len+1);
5811
5812                 /*
5813                  * Ensure it ends in a '/'.
5814                  * We used TALLOC_SIZE +2 to add space for the '/'.
5815                  */
5816
5817                 if(dir_name_len
5818                     && (parent_fname[dir_name_len-1] != '\\')
5819                     && (parent_fname[dir_name_len-1] != '/')) {
5820                         parent_fname[dir_name_len] = '/';
5821                         parent_fname[dir_name_len+1] = '\0';
5822                 }
5823         }
5824
5825         new_base_name = talloc_asprintf(talloc_tos(), "%s%s", parent_fname,
5826                                         smb_fname->base_name);
5827         if (new_base_name == NULL) {
5828                 status = NT_STATUS_NO_MEMORY;
5829                 goto out;
5830         }
5831
5832         status = filename_convert(req,
5833                                 conn,
5834                                 new_base_name,
5835                                 ucf_flags,
5836                                 NULL,
5837                                 NULL,
5838                                 smb_fname_out);
5839         if (!NT_STATUS_IS_OK(status)) {
5840                 goto out;
5841         }
5842
5843  out:
5844         TALLOC_FREE(parent_fname);
5845         TALLOC_FREE(new_base_name);
5846         return status;
5847 }
5848
5849 NTSTATUS create_file_default(connection_struct *conn,
5850                              struct smb_request *req,
5851                              uint16_t root_dir_fid,
5852                              struct smb_filename *smb_fname,
5853                              uint32_t access_mask,
5854                              uint32_t share_access,
5855                              uint32_t create_disposition,
5856                              uint32_t create_options,
5857                              uint32_t file_attributes,
5858                              uint32_t oplock_request,
5859                              const struct smb2_lease *lease,
5860                              uint64_t allocation_size,
5861                              uint32_t private_flags,
5862                              struct security_descriptor *sd,
5863                              struct ea_list *ea_list,
5864                              files_struct **result,
5865                              int *pinfo,
5866                              const struct smb2_create_blobs *in_context_blobs,
5867                              struct smb2_create_blobs *out_context_blobs)
5868 {
5869         int info = FILE_WAS_OPENED;
5870         files_struct *fsp = NULL;
5871         NTSTATUS status;
5872         bool stream_name = false;
5873
5874         DBG_DEBUG("create_file: access_mask = 0x%x "
5875                   "file_attributes = 0x%x, share_access = 0x%x, "
5876                   "create_disposition = 0x%x create_options = 0x%x "
5877                   "oplock_request = 0x%x "
5878                   "private_flags = 0x%x "
5879                   "root_dir_fid = 0x%x, ea_list = %p, sd = %p, "
5880                   "fname = %s\n",
5881                   (unsigned int)access_mask,
5882                   (unsigned int)file_attributes,
5883                   (unsigned int)share_access,
5884                   (unsigned int)create_disposition,
5885                   (unsigned int)create_options,
5886                   (unsigned int)oplock_request,
5887                   (unsigned int)private_flags,
5888                   (unsigned int)root_dir_fid,
5889                   ea_list, sd, smb_fname_str_dbg(smb_fname));
5890
5891         if (req != NULL) {
5892                 /*
5893                  * Remember the absolute time of the original request
5894                  * with this mid. We'll use it later to see if this
5895                  * has timed out.
5896                  */
5897                 get_deferred_open_message_state(req, &req->request_time, NULL);
5898         }
5899
5900         /*
5901          * Calculate the filename from the root_dir_if if necessary.
5902          */
5903
5904         if (root_dir_fid != 0) {
5905                 struct smb_filename *smb_fname_out = NULL;
5906                 status = get_relative_fid_filename(conn, req, root_dir_fid,
5907                                                    smb_fname, &smb_fname_out);
5908                 if (!NT_STATUS_IS_OK(status)) {
5909                         goto fail;
5910                 }
5911                 smb_fname = smb_fname_out;
5912         }
5913
5914         /*
5915          * Check to see if this is a mac fork of some kind.
5916          */
5917
5918         stream_name = is_ntfs_stream_smb_fname(smb_fname);
5919         if (stream_name) {
5920                 enum FAKE_FILE_TYPE fake_file_type;
5921
5922                 fake_file_type = is_fake_file(smb_fname);
5923
5924                 if (fake_file_type != FAKE_FILE_TYPE_NONE) {
5925
5926                         /*
5927                          * Here we go! support for changing the disk quotas
5928                          * --metze
5929                          *
5930                          * We need to fake up to open this MAGIC QUOTA file
5931                          * and return a valid FID.
5932                          *
5933                          * w2k close this file directly after openening xp
5934                          * also tries a QUERY_FILE_INFO on the file and then
5935                          * close it
5936                          */
5937                         status = open_fake_file(req, conn, req->vuid,
5938                                                 fake_file_type, smb_fname,
5939                                                 access_mask, &fsp);
5940                         if (!NT_STATUS_IS_OK(status)) {
5941                                 goto fail;
5942                         }
5943
5944                         ZERO_STRUCT(smb_fname->st);
5945                         goto done;
5946                 }
5947
5948                 if (!(conn->fs_capabilities & FILE_NAMED_STREAMS)) {
5949                         status = NT_STATUS_OBJECT_NAME_NOT_FOUND;
5950                         goto fail;
5951                 }
5952         }
5953
5954         if (is_ntfs_default_stream_smb_fname(smb_fname)) {
5955                 int ret;
5956                 smb_fname->stream_name = NULL;
5957                 /* We have to handle this error here. */
5958                 if (create_options & FILE_DIRECTORY_FILE) {
5959                         status = NT_STATUS_NOT_A_DIRECTORY;
5960                         goto fail;
5961                 }
5962                 if (req != NULL && req->posix_pathnames) {
5963                         ret = SMB_VFS_LSTAT(conn, smb_fname);
5964                 } else {
5965                         ret = SMB_VFS_STAT(conn, smb_fname);
5966                 }
5967
5968                 if (ret == 0 && VALID_STAT_OF_DIR(smb_fname->st)) {
5969                         status = NT_STATUS_FILE_IS_A_DIRECTORY;
5970                         goto fail;
5971                 }
5972         }
5973
5974         status = create_file_unixpath(
5975                 conn, req, smb_fname, access_mask, share_access,
5976                 create_disposition, create_options, file_attributes,
5977                 oplock_request, lease, allocation_size, private_flags,
5978                 sd, ea_list,
5979                 &fsp, &info);
5980
5981         if (!NT_STATUS_IS_OK(status)) {
5982                 goto fail;
5983         }
5984
5985  done:
5986         DEBUG(10, ("create_file: info=%d\n", info));
5987
5988         *result = fsp;
5989         if (pinfo != NULL) {
5990                 *pinfo = info;
5991         }
5992         return NT_STATUS_OK;
5993
5994  fail:
5995         DEBUG(10, ("create_file: %s\n", nt_errstr(status)));
5996
5997         if (fsp != NULL) {
5998                 close_file(req, fsp, ERROR_CLOSE);
5999                 fsp = NULL;
6000         }
6001         return status;
6002 }