source3/smbd/open.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    file opening and share modes
   4    Copyright (C) Andrew Tridgell 1992-1998
   5    Copyright (C) Jeremy Allison 2001-2004
   6    Copyright (C) Volker Lendecke 2005
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20 */
  21
  22 #include "includes.h"
  23 #include "smbd/globals.h"
  24
  25 extern struct current_user current_user;
  26 extern const struct generic_mapping file_generic_mapping;
  27
  28 struct deferred_open_record {
  29         bool delayed_for_oplocks;
  30         struct file_id id;
  31 };
  32
  33 static NTSTATUS create_file_unixpath(connection_struct *conn,
  34                                      struct smb_request *req,
  35                                      struct smb_filename *smb_fname,
  36                                      uint32_t access_mask,
  37                                      uint32_t share_access,
  38                                      uint32_t create_disposition,
  39                                      uint32_t create_options,
  40                                      uint32_t file_attributes,
  41                                      uint32_t oplock_request,
  42                                      uint64_t allocation_size,
  43                                      struct security_descriptor *sd,
  44                                      struct ea_list *ea_list,
  45
  46                                      files_struct **result,
  47                                      int *pinfo);
  48
  49 /****************************************************************************
  50  SMB1 file varient of se_access_check. Never test FILE_READ_ATTRIBUTES.
  51 ****************************************************************************/
  52
  53 NTSTATUS smb1_file_se_access_check(connection_struct *conn,
  54                           const struct security_descriptor *sd,
  55                           const NT_USER_TOKEN *token,
  56                           uint32_t access_desired,
  57                           uint32_t *access_granted)
  58 {
  59         *access_granted = 0;
  60
  61         if (conn->server_info->utok.uid == 0 || conn->admin_user) {
  62                 /* I'm sorry sir, I didn't know you were root... */
  63                 *access_granted = access_desired;
  64                 if (access_desired & SEC_FLAG_MAXIMUM_ALLOWED) {
  65                         *access_granted |= FILE_GENERIC_ALL;
  66                 }
  67                 return NT_STATUS_OK;
  68         }
  69
  70         return se_access_check(sd,
  71                                 token,
  72                                 (access_desired & ~FILE_READ_ATTRIBUTES),
  73                                 access_granted);
  74 }
  75
  76 /****************************************************************************
  77  Check if we have open rights.
  78 ****************************************************************************/
  79
  80 NTSTATUS smbd_check_open_rights(struct connection_struct *conn,
  81                                 const struct smb_filename *smb_fname,
  82                                 uint32_t access_mask,
  83                                 uint32_t *access_granted)
  84 {
  85         /* Check if we have rights to open. */
  86         NTSTATUS status;
  87         struct security_descriptor *sd = NULL;
  88
  89         status = SMB_VFS_GET_NT_ACL(conn, smb_fname->base_name,
  90                         (OWNER_SECURITY_INFORMATION |
  91                         GROUP_SECURITY_INFORMATION |
  92                         DACL_SECURITY_INFORMATION),&sd);
  93
  94         if (!NT_STATUS_IS_OK(status)) {
  95                 DEBUG(10, ("smbd_check_open_rights: Could not get acl "
  96                         "on %s: %s\n",
  97                         smb_fname_str_dbg(smb_fname),
  98                         nt_errstr(status)));
  99                 return status;
 100         }
 101
 102         status = smb1_file_se_access_check(conn,
 103                                 sd,
 104                                 conn->server_info->ptok,
 105                                 access_mask,
 106                                 access_granted);
 107
 108         DEBUG(10,("smbd_check_open_rights: file %s requesting "
 109                 "0x%x returning 0x%x (%s)\n",
 110                 smb_fname_str_dbg(smb_fname),
 111                 (unsigned int)access_mask,
 112                 (unsigned int)*access_granted,
 113                 nt_errstr(status) ));
 114
 115         if (!NT_STATUS_IS_OK(status)) {
 116                 if (DEBUGLEVEL >= 10) {
 117                         DEBUG(10,("smbd_check_open_rights: acl for %s is:\n",
 118                                 smb_fname_str_dbg(smb_fname) ));
 119                         NDR_PRINT_DEBUG(security_descriptor, sd);
 120                 }
 121         }
 122
 123         TALLOC_FREE(sd);
 124
 125         return status;
 126 }
 127
 128 /****************************************************************************
 129  fd support routines - attempt to do a dos_open.
 130 ****************************************************************************/
 131
 132 static NTSTATUS fd_open(struct connection_struct *conn,
 133                     files_struct *fsp,
 134                     int flags,
 135                     mode_t mode)
 136 {
 137         struct smb_filename *smb_fname = fsp->fsp_name;
 138         NTSTATUS status = NT_STATUS_OK;
 139
 140 #ifdef O_NOFOLLOW
 141         /*
 142          * Never follow symlinks on a POSIX client. The
 143          * client should be doing this.
 144          */
 145
 146         if (fsp->posix_open || !lp_symlinks(SNUM(conn))) {
 147                 flags |= O_NOFOLLOW;
 148         }
 149 #endif
 150
 151         fsp->fh->fd = SMB_VFS_OPEN(conn, smb_fname, fsp, flags, mode);
 152         if (fsp->fh->fd == -1) {
 153                 status = map_nt_error_from_unix(errno);
 154                 if (errno == EMFILE) {
 155                         static time_t last_warned = 0L;
 156
 157                         if (time((time_t *) NULL) > last_warned) {
 158                                 DEBUG(0,("Too many open files, unable "
 159                                         "to open more!  smbd's max "
 160                                         "open files = %d\n",
 161                                         lp_max_open_files()));
 162                                 last_warned = time((time_t *) NULL);
 163                         }
 164                 }
 165
 166         }
 167
 168         DEBUG(10,("fd_open: name %s, flags = 0%o mode = 0%o, fd = %d. %s\n",
 169                   smb_fname_str_dbg(smb_fname), flags, (int)mode, fsp->fh->fd,
 170                 (fsp->fh->fd == -1) ? strerror(errno) : "" ));
 171
 172         return status;
 173 }
 174
 175 /****************************************************************************
 176  Close the file associated with a fsp.
 177 ****************************************************************************/
 178
 179 NTSTATUS fd_close(files_struct *fsp)
 180 {
 181         int ret;
 182
 183         if (fsp->fh->fd == -1) {
 184                 return NT_STATUS_OK; /* What we used to call a stat open. */
 185         }
 186         if (fsp->fh->ref_count > 1) {
 187                 return NT_STATUS_OK; /* Shared handle. Only close last reference. */
 188         }
 189
 190         ret = SMB_VFS_CLOSE(fsp);
 191         fsp->fh->fd = -1;
 192         if (ret == -1) {
 193                 return map_nt_error_from_unix(errno);
 194         }
 195         return NT_STATUS_OK;
 196 }
 197
 198 /****************************************************************************
 199  Change the ownership of a file to that of the parent directory.
 200  Do this by fd if possible.
 201 ****************************************************************************/
 202
 203 void change_file_owner_to_parent(connection_struct *conn,
 204                                         const char *inherit_from_dir,
 205                                         files_struct *fsp)
 206 {
 207         struct smb_filename *smb_fname_parent = NULL;
 208         NTSTATUS status;
 209         int ret;
 210
 211         status = create_synthetic_smb_fname(talloc_tos(), inherit_from_dir,
 212                                             NULL, NULL, &smb_fname_parent);
 213         if (!NT_STATUS_IS_OK(status)) {
 214                 return;
 215         }
 216
 217         ret = SMB_VFS_STAT(conn, smb_fname_parent);
 218         if (ret == -1) {
 219                 DEBUG(0,("change_file_owner_to_parent: failed to stat parent "
 220                          "directory %s. Error was %s\n",
 221                          smb_fname_str_dbg(smb_fname_parent),
 222                          strerror(errno)));
 223                 return;
 224         }
 225
 226         become_root();
 227         ret = SMB_VFS_FCHOWN(fsp, smb_fname_parent->st.st_ex_uid, (gid_t)-1);
 228         unbecome_root();
 229         if (ret == -1) {
 230                 DEBUG(0,("change_file_owner_to_parent: failed to fchown "
 231                          "file %s to parent directory uid %u. Error "
 232                          "was %s\n", fsp_str_dbg(fsp),
 233                          (unsigned int)smb_fname_parent->st.st_ex_uid,
 234                          strerror(errno) ));
 235         }
 236
 237         DEBUG(10,("change_file_owner_to_parent: changed new file %s to "
 238                   "parent directory uid %u.\n", fsp_str_dbg(fsp),
 239                   (unsigned int)smb_fname_parent->st.st_ex_uid));
 240
 241         TALLOC_FREE(smb_fname_parent);
 242 }
 243
 244 NTSTATUS change_dir_owner_to_parent(connection_struct *conn,
 245                                        const char *inherit_from_dir,
 246                                        const char *fname,
 247                                        SMB_STRUCT_STAT *psbuf)
 248 {
 249         struct smb_filename *smb_fname_parent = NULL;
 250         struct smb_filename *smb_fname_cwd = NULL;
 251         char *saved_dir = NULL;
 252         TALLOC_CTX *ctx = talloc_tos();
 253         NTSTATUS status = NT_STATUS_OK;
 254         int ret;
 255
 256         status = create_synthetic_smb_fname(ctx, inherit_from_dir, NULL, NULL,
 257                                             &smb_fname_parent);
 258         if (!NT_STATUS_IS_OK(status)) {
 259                 return status;
 260         }
 261
 262         ret = SMB_VFS_STAT(conn, smb_fname_parent);
 263         if (ret == -1) {
 264                 status = map_nt_error_from_unix(errno);
 265                 DEBUG(0,("change_dir_owner_to_parent: failed to stat parent "
 266                          "directory %s. Error was %s\n",
 267                          smb_fname_str_dbg(smb_fname_parent),
 268                          strerror(errno)));
 269                 goto out;
 270         }
 271
 272         /* We've already done an lstat into psbuf, and we know it's a
 273            directory. If we can cd into the directory and the dev/ino
 274            are the same then we can safely chown without races as
 275            we're locking the directory in place by being in it.  This
 276            should work on any UNIX (thanks tridge :-). JRA.
 277         */
 278
 279         saved_dir = vfs_GetWd(ctx,conn);
 280         if (!saved_dir) {
 281                 status = map_nt_error_from_unix(errno);
 282                 DEBUG(0,("change_dir_owner_to_parent: failed to get "
 283                          "current working directory. Error was %s\n",
 284                          strerror(errno)));
 285                 goto out;
 286         }
 287
 288         /* Chdir into the new path. */
 289         if (vfs_ChDir(conn, fname) == -1) {
 290                 status = map_nt_error_from_unix(errno);
 291                 DEBUG(0,("change_dir_owner_to_parent: failed to change "
 292                          "current working directory to %s. Error "
 293                          "was %s\n", fname, strerror(errno) ));
 294                 goto chdir;
 295         }
 296
 297         status = create_synthetic_smb_fname(ctx, ".", NULL, NULL,
 298                                             &smb_fname_cwd);
 299         if (!NT_STATUS_IS_OK(status)) {
 300                 return status;
 301         }
 302
 303         ret = SMB_VFS_STAT(conn, smb_fname_cwd);
 304         if (ret == -1) {
 305                 status = map_nt_error_from_unix(errno);
 306                 DEBUG(0,("change_dir_owner_to_parent: failed to stat "
 307                          "directory '.' (%s) Error was %s\n",
 308                          fname, strerror(errno)));
 309                 goto chdir;
 310         }
 311
 312         /* Ensure we're pointing at the same place. */
 313         if (smb_fname_cwd->st.st_ex_dev != psbuf->st_ex_dev ||
 314             smb_fname_cwd->st.st_ex_ino != psbuf->st_ex_ino ||
 315             smb_fname_cwd->st.st_ex_mode != psbuf->st_ex_mode ) {
 316                 DEBUG(0,("change_dir_owner_to_parent: "
 317                          "device/inode/mode on directory %s changed. "
 318                          "Refusing to chown !\n", fname ));
 319                 status = NT_STATUS_ACCESS_DENIED;
 320                 goto chdir;
 321         }
 322
 323         become_root();
 324         ret = SMB_VFS_CHOWN(conn, ".", smb_fname_parent->st.st_ex_uid,
 325                             (gid_t)-1);
 326         unbecome_root();
 327         if (ret == -1) {
 328                 status = map_nt_error_from_unix(errno);
 329                 DEBUG(10,("change_dir_owner_to_parent: failed to chown "
 330                           "directory %s to parent directory uid %u. "
 331                           "Error was %s\n", fname,
 332                           (unsigned int)smb_fname_parent->st.st_ex_uid,
 333                           strerror(errno) ));
 334                 goto chdir;
 335         }
 336
 337         DEBUG(10,("change_dir_owner_to_parent: changed ownership of new "
 338                   "directory %s to parent directory uid %u.\n",
 339                   fname, (unsigned int)smb_fname_parent->st.st_ex_uid ));
 340
 341  chdir:
 342         vfs_ChDir(conn,saved_dir);
 343  out:
 344         TALLOC_FREE(smb_fname_parent);
 345         TALLOC_FREE(smb_fname_cwd);
 346         return status;
 347 }
 348
 349 /****************************************************************************
 350  Open a file.
 351 ****************************************************************************/
 352
 353 static NTSTATUS open_file(files_struct *fsp,
 354                           connection_struct *conn,
 355                           struct smb_request *req,
 356                           const char *parent_dir,
 357                           int flags,
 358                           mode_t unx_mode,
 359                           uint32 access_mask, /* client requested access mask. */
 360                           uint32 open_access_mask) /* what we're actually using in the open. */
 361 {
 362         struct smb_filename *smb_fname = fsp->fsp_name;
 363         NTSTATUS status = NT_STATUS_OK;
 364         int accmode = (flags & O_ACCMODE);
 365         int local_flags = flags;
 366         bool file_existed = VALID_STAT(fsp->fsp_name->st);
 367
 368         fsp->fh->fd = -1;
 369         errno = EPERM;
 370
 371         /* Check permissions */
 372
 373         /*
 374          * This code was changed after seeing a client open request
 375          * containing the open mode of (DENY_WRITE/read-only) with
 376          * the 'create if not exist' bit set. The previous code
 377          * would fail to open the file read only on a read-only share
 378          * as it was checking the flags parameter  directly against O_RDONLY,
 379          * this was failing as the flags parameter was set to O_RDONLY|O_CREAT.
 380          * JRA.
 381          */
 382
 383         if (!CAN_WRITE(conn)) {
 384                 /* It's a read-only share - fail if we wanted to write. */
 385                 if(accmode != O_RDONLY || (flags & O_TRUNC) || (flags & O_APPEND)) {
 386                         DEBUG(3,("Permission denied opening %s\n",
 387                                  smb_fname_str_dbg(smb_fname)));
 388                         return NT_STATUS_ACCESS_DENIED;
 389                 } else if(flags & O_CREAT) {
 390                         /* We don't want to write - but we must make sure that
 391                            O_CREAT doesn't create the file if we have write
 392                            access into the directory.
 393                         */
 394                         flags &= ~(O_CREAT|O_EXCL);
 395                         local_flags &= ~(O_CREAT|O_EXCL);
 396                 }
 397         }
 398
 399         /*
 400          * This little piece of insanity is inspired by the
 401          * fact that an NT client can open a file for O_RDONLY,
 402          * but set the create disposition to FILE_EXISTS_TRUNCATE.
 403          * If the client *can* write to the file, then it expects to
 404          * truncate the file, even though it is opening for readonly.
 405          * Quicken uses this stupid trick in backup file creation...
 406          * Thanks *greatly* to "David W. Chapman Jr." <dwcjr@inethouston.net>
 407          * for helping track this one down. It didn't bite us in 2.0.x
 408          * as we always opened files read-write in that release. JRA.
 409          */
 410
 411         if ((accmode == O_RDONLY) && ((flags & O_TRUNC) == O_TRUNC)) {
 412                 DEBUG(10,("open_file: truncate requested on read-only open "
 413                           "for file %s\n", smb_fname_str_dbg(smb_fname)));
 414                 local_flags = (flags & ~O_ACCMODE)|O_RDWR;
 415         }
 416
 417         if ((open_access_mask & (FILE_READ_DATA|FILE_WRITE_DATA|FILE_APPEND_DATA|FILE_EXECUTE)) ||
 418             (!file_existed && (local_flags & O_CREAT)) ||
 419             ((local_flags & O_TRUNC) == O_TRUNC) ) {
 420                 const char *wild;
 421
 422                 /*
 423                  * We can't actually truncate here as the file may be locked.
 424                  * open_file_ntcreate will take care of the truncate later. JRA.
 425                  */
 426
 427                 local_flags &= ~O_TRUNC;
 428
 429 #if defined(O_NONBLOCK) && defined(S_ISFIFO)
 430                 /*
 431                  * We would block on opening a FIFO with no one else on the
 432                  * other end. Do what we used to do and add O_NONBLOCK to the
 433                  * open flags. JRA.
 434                  */
 435
 436                 if (file_existed && S_ISFIFO(smb_fname->st.st_ex_mode)) {
 437                         local_flags |= O_NONBLOCK;
 438                 }
 439 #endif
 440
 441                 /* Don't create files with Microsoft wildcard characters. */
 442                 if (fsp->base_fsp) {
 443                         /*
 444                          * wildcard characters are allowed in stream names
 445                          * only test the basefilename
 446                          */
 447                         wild = fsp->base_fsp->fsp_name->base_name;
 448                 } else {
 449                         wild = smb_fname->base_name;
 450                 }
 451                 if ((local_flags & O_CREAT) && !file_existed &&
 452                     ms_has_wild(wild))  {
 453                         return NT_STATUS_OBJECT_NAME_INVALID;
 454                 }
 455
 456                 /* Actually do the open */
 457                 status = fd_open(conn, fsp, local_flags, unx_mode);
 458                 if (!NT_STATUS_IS_OK(status)) {
 459                         DEBUG(3,("Error opening file %s (%s) (local_flags=%d) "
 460                                  "(flags=%d)\n", smb_fname_str_dbg(smb_fname),
 461                                  nt_errstr(status),local_flags,flags));
 462                         return status;
 463                 }
 464
 465                 if ((local_flags & O_CREAT) && !file_existed) {
 466
 467                         /* Inherit the ACL if required */
 468                         if (lp_inherit_perms(SNUM(conn))) {
 469                                 inherit_access_posix_acl(conn, parent_dir,
 470                                                          smb_fname->base_name,
 471                                                          unx_mode);
 472                         }
 473
 474                         /* Change the owner if required. */
 475                         if (lp_inherit_owner(SNUM(conn))) {
 476                                 change_file_owner_to_parent(conn, parent_dir,
 477                                                             fsp);
 478                         }
 479
 480                         notify_fname(conn, NOTIFY_ACTION_ADDED,
 481                                      FILE_NOTIFY_CHANGE_FILE_NAME,
 482                                      smb_fname->base_name);
 483                 }
 484
 485         } else {
 486                 fsp->fh->fd = -1; /* What we used to call a stat open. */
 487                 if (file_existed) {
 488                         uint32_t access_granted = 0;
 489
 490                         status = smbd_check_open_rights(conn,
 491                                         smb_fname,
 492                                         access_mask,
 493                                         &access_granted);
 494                         if (!NT_STATUS_IS_OK(status)) {
 495                                 if (NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED)) {
 496                                         /*
 497                                          * On NT_STATUS_ACCESS_DENIED, access_granted
 498                                          * contains the denied bits.
 499                                          */
 500
 501                                         if ((access_mask & FILE_WRITE_ATTRIBUTES) &&
 502                                                         (access_granted & FILE_WRITE_ATTRIBUTES) &&
 503                                                         (lp_map_readonly(SNUM(conn)) ||
 504                                                          lp_map_archive(SNUM(conn)) ||
 505                                                          lp_map_hidden(SNUM(conn)) ||
 506                                                          lp_map_system(SNUM(conn)))) {
 507                                                 access_granted &= ~FILE_WRITE_ATTRIBUTES;
 508
 509                                                 DEBUG(10,("open_file: "
 510                                                           "overrode "
 511                                                           "FILE_WRITE_"
 512                                                           "ATTRIBUTES "
 513                                                           "on file %s\n",
 514                                                           smb_fname_str_dbg(
 515                                                                   smb_fname)));
 516                                         }
 517
 518                                         if ((access_mask & DELETE_ACCESS) &&
 519                                             (access_granted & DELETE_ACCESS) &&
 520                                             can_delete_file_in_directory(conn,
 521                                                 smb_fname)) {
 522                                                 /* Were we trying to do a stat open
 523                                                  * for delete and didn't get DELETE
 524                                                  * access (only) ? Check if the
 525                                                  * directory allows DELETE_CHILD.
 526                                                  * See here:
 527                                                  * http://blogs.msdn.com/oldnewthing/archive/2004/06/04/148426.aspx
 528                                                  * for details. */
 529
 530                                                 access_granted &= ~DELETE_ACCESS;
 531
 532                                                 DEBUG(10,("open_file: "
 533                                                           "overrode "
 534                                                           "DELETE_ACCESS on "
 535                                                           "file %s\n",
 536                                                           smb_fname_str_dbg(
 537                                                                   smb_fname)));
 538                                         }
 539
 540                                         if (access_granted != 0) {
 541                                                 DEBUG(10,("open_file: Access "
 542                                                           "denied on file "
 543                                                           "%s\n",
 544                                                           smb_fname_str_dbg(
 545                                                                   smb_fname)));
 546                                                 return status;
 547                                         }
 548                                 } else if (NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND) &&
 549                                     fsp->posix_open &&
 550                                     S_ISLNK(smb_fname->st.st_ex_mode)) {
 551                                         /* This is a POSIX stat open for delete
 552                                          * or rename on a symlink that points
 553                                          * nowhere. Allow. */
 554                                         DEBUG(10,("open_file: allowing POSIX "
 555                                                   "open on bad symlink %s\n",
 556                                                   smb_fname_str_dbg(
 557                                                           smb_fname)));
 558                                 } else {
 559                                         DEBUG(10,("open_file: "
 560                                                   "smbd_check_open_rights on file "
 561                                                   "%s returned %s\n",
 562                                                   smb_fname_str_dbg(smb_fname),
 563                                                   nt_errstr(status) ));
 564                                         return status;
 565                                 }
 566                         }
 567                 }
 568         }
 569
 570         if (!file_existed) {
 571                 int ret;
 572
 573                 if (fsp->fh->fd == -1) {
 574                         ret = SMB_VFS_STAT(conn, smb_fname);
 575                 } else {
 576                         ret = SMB_VFS_FSTAT(fsp, &smb_fname->st);
 577                         /* If we have an fd, this stat should succeed. */
 578                         if (ret == -1) {
 579                                 DEBUG(0,("Error doing fstat on open file %s "
 580                                          "(%s)\n",
 581                                          smb_fname_str_dbg(smb_fname),
 582                                          strerror(errno) ));
 583                         }
 584                 }
 585
 586                 /* For a non-io open, this stat failing means file not found. JRA */
 587                 if (ret == -1) {
 588                         status = map_nt_error_from_unix(errno);
 589                         fd_close(fsp);
 590                         return status;
 591                 }
 592         }
 593
 594         /*
 595          * POSIX allows read-only opens of directories. We don't
 596          * want to do this (we use a different code path for this)
 597          * so catch a directory open and return an EISDIR. JRA.
 598          */
 599
 600         if(S_ISDIR(smb_fname->st.st_ex_mode)) {
 601                 fd_close(fsp);
 602                 errno = EISDIR;
 603                 return NT_STATUS_FILE_IS_A_DIRECTORY;
 604         }
 605
 606         fsp->mode = smb_fname->st.st_ex_mode;
 607         fsp->file_id = vfs_file_id_from_sbuf(conn, &smb_fname->st);
 608         fsp->vuid = req ? req->vuid : UID_FIELD_INVALID;
 609         fsp->file_pid = req ? req->smbpid : 0;
 610         fsp->can_lock = True;
 611         fsp->can_read = (access_mask & (FILE_READ_DATA)) ? True : False;
 612         if (!CAN_WRITE(conn)) {
 613                 fsp->can_write = False;
 614         } else {
 615                 fsp->can_write = (access_mask & (FILE_WRITE_DATA | FILE_APPEND_DATA)) ?
 616                         True : False;
 617         }
 618         fsp->print_file = False;
 619         fsp->modified = False;
 620         fsp->sent_oplock_break = NO_BREAK_SENT;
 621         fsp->is_directory = False;
 622         if (conn->aio_write_behind_list &&
 623             is_in_path(smb_fname->base_name, conn->aio_write_behind_list,
 624                        conn->case_sensitive)) {
 625                 fsp->aio_write_behind = True;
 626         }
 627
 628         fsp->wcp = NULL; /* Write cache pointer. */
 629
 630         DEBUG(2,("%s opened file %s read=%s write=%s (numopen=%d)\n",
 631                  conn->server_info->unix_name,
 632                  smb_fname_str_dbg(smb_fname),
 633                  BOOLSTR(fsp->can_read), BOOLSTR(fsp->can_write),
 634                  conn->num_files_open));
 635
 636         errno = 0;
 637         return NT_STATUS_OK;
 638 }
 639
 640 /*******************************************************************
 641  Return True if the filename is one of the special executable types.
 642 ********************************************************************/
 643
 644 bool is_executable(const char *fname)
 645 {
 646         if ((fname = strrchr_m(fname,'.'))) {
 647                 if (strequal(fname,".com") ||
 648                     strequal(fname,".dll") ||
 649                     strequal(fname,".exe") ||
 650                     strequal(fname,".sym")) {
 651                         return True;
 652                 }
 653         }
 654         return False;
 655 }
 656
 657 /****************************************************************************
 658  Check if we can open a file with a share mode.
 659  Returns True if conflict, False if not.
 660 ****************************************************************************/
 661
 662 static bool share_conflict(struct share_mode_entry *entry,
 663                            uint32 access_mask,
 664                            uint32 share_access)
 665 {
 666         DEBUG(10,("share_conflict: entry->access_mask = 0x%x, "
 667                   "entry->share_access = 0x%x, "
 668                   "entry->private_options = 0x%x\n",
 669                   (unsigned int)entry->access_mask,
 670                   (unsigned int)entry->share_access,
 671                   (unsigned int)entry->private_options));
 672
 673         DEBUG(10,("share_conflict: access_mask = 0x%x, share_access = 0x%x\n",
 674                   (unsigned int)access_mask, (unsigned int)share_access));
 675
 676         if ((entry->access_mask & (FILE_WRITE_DATA|
 677                                    FILE_APPEND_DATA|
 678                                    FILE_READ_DATA|
 679                                    FILE_EXECUTE|
 680                                    DELETE_ACCESS)) == 0) {
 681                 DEBUG(10,("share_conflict: No conflict due to "
 682                           "entry->access_mask = 0x%x\n",
 683                           (unsigned int)entry->access_mask ));
 684                 return False;
 685         }
 686
 687         if ((access_mask & (FILE_WRITE_DATA|
 688                             FILE_APPEND_DATA|
 689                             FILE_READ_DATA|
 690                             FILE_EXECUTE|
 691                             DELETE_ACCESS)) == 0) {
 692                 DEBUG(10,("share_conflict: No conflict due to "
 693                           "access_mask = 0x%x\n",
 694                           (unsigned int)access_mask ));
 695                 return False;
 696         }
 697
 698 #if 1 /* JRA TEST - Superdebug. */
 699 #define CHECK_MASK(num, am, right, sa, share) \
 700         DEBUG(10,("share_conflict: [%d] am (0x%x) & right (0x%x) = 0x%x\n", \
 701                 (unsigned int)(num), (unsigned int)(am), \
 702                 (unsigned int)(right), (unsigned int)(am)&(right) )); \
 703         DEBUG(10,("share_conflict: [%d] sa (0x%x) & share (0x%x) = 0x%x\n", \
 704                 (unsigned int)(num), (unsigned int)(sa), \
 705                 (unsigned int)(share), (unsigned int)(sa)&(share) )); \
 706         if (((am) & (right)) && !((sa) & (share))) { \
 707                 DEBUG(10,("share_conflict: check %d conflict am = 0x%x, right = 0x%x, \
 708 sa = 0x%x, share = 0x%x\n", (num), (unsigned int)(am), (unsigned int)(right), (unsigned int)(sa), \
 709                         (unsigned int)(share) )); \
 710                 return True; \
 711         }
 712 #else
 713 #define CHECK_MASK(num, am, right, sa, share) \
 714         if (((am) & (right)) && !((sa) & (share))) { \
 715                 DEBUG(10,("share_conflict: check %d conflict am = 0x%x, right = 0x%x, \
 716 sa = 0x%x, share = 0x%x\n", (num), (unsigned int)(am), (unsigned int)(right), (unsigned int)(sa), \
 717                         (unsigned int)(share) )); \
 718                 return True; \
 719         }
 720 #endif
 721
 722         CHECK_MASK(1, entry->access_mask, FILE_WRITE_DATA | FILE_APPEND_DATA,
 723                    share_access, FILE_SHARE_WRITE);
 724         CHECK_MASK(2, access_mask, FILE_WRITE_DATA | FILE_APPEND_DATA,
 725                    entry->share_access, FILE_SHARE_WRITE);
 726
 727         CHECK_MASK(3, entry->access_mask, FILE_READ_DATA | FILE_EXECUTE,
 728                    share_access, FILE_SHARE_READ);
 729         CHECK_MASK(4, access_mask, FILE_READ_DATA | FILE_EXECUTE,
 730                    entry->share_access, FILE_SHARE_READ);
 731
 732         CHECK_MASK(5, entry->access_mask, DELETE_ACCESS,
 733                    share_access, FILE_SHARE_DELETE);
 734         CHECK_MASK(6, access_mask, DELETE_ACCESS,
 735                    entry->share_access, FILE_SHARE_DELETE);
 736
 737         DEBUG(10,("share_conflict: No conflict.\n"));
 738         return False;
 739 }
 740
 741 #if defined(DEVELOPER)
 742 static void validate_my_share_entries(int num,
 743                                       struct share_mode_entry *share_entry)
 744 {
 745         files_struct *fsp;
 746
 747         if (!procid_is_me(&share_entry->pid)) {
 748                 return;
 749         }
 750
 751         if (is_deferred_open_entry(share_entry) &&
 752             !open_was_deferred(share_entry->op_mid)) {
 753                 char *str = talloc_asprintf(talloc_tos(),
 754                         "Got a deferred entry without a request: "
 755                         "PANIC: %s\n",
 756                         share_mode_str(talloc_tos(), num, share_entry));
 757                 smb_panic(str);
 758         }
 759
 760         if (!is_valid_share_mode_entry(share_entry)) {
 761                 return;
 762         }
 763
 764         fsp = file_find_dif(share_entry->id,
 765                             share_entry->share_file_id);
 766         if (!fsp) {
 767                 DEBUG(0,("validate_my_share_entries: PANIC : %s\n",
 768                          share_mode_str(talloc_tos(), num, share_entry) ));
 769                 smb_panic("validate_my_share_entries: Cannot match a "
 770                           "share entry with an open file\n");
 771         }
 772
 773         if (is_deferred_open_entry(share_entry) ||
 774             is_unused_share_mode_entry(share_entry)) {
 775                 goto panic;
 776         }
 777
 778         if ((share_entry->op_type == NO_OPLOCK) &&
 779             (fsp->oplock_type == FAKE_LEVEL_II_OPLOCK)) {
 780                 /* Someone has already written to it, but I haven't yet
 781                  * noticed */
 782                 return;
 783         }
 784
 785         if (((uint16)fsp->oplock_type) != share_entry->op_type) {
 786                 goto panic;
 787         }
 788
 789         return;
 790
 791  panic:
 792         {
 793                 char *str;
 794                 DEBUG(0,("validate_my_share_entries: PANIC : %s\n",
 795                          share_mode_str(talloc_tos(), num, share_entry) ));
 796                 str = talloc_asprintf(talloc_tos(),
 797                         "validate_my_share_entries: "
 798                         "file %s, oplock_type = 0x%x, op_type = 0x%x\n",
 799                          fsp->fsp_name->base_name,
 800                          (unsigned int)fsp->oplock_type,
 801                          (unsigned int)share_entry->op_type );
 802                 smb_panic(str);
 803         }
 804 }
 805 #endif
 806
 807 bool is_stat_open(uint32 access_mask)
 808 {
 809         return (access_mask &&
 810                 ((access_mask & ~(SYNCHRONIZE_ACCESS| FILE_READ_ATTRIBUTES|
 811                                   FILE_WRITE_ATTRIBUTES))==0) &&
 812                 ((access_mask & (SYNCHRONIZE_ACCESS|FILE_READ_ATTRIBUTES|
 813                                  FILE_WRITE_ATTRIBUTES)) != 0));
 814 }
 815
 816 /****************************************************************************
 817  Deal with share modes
 818  Invarient: Share mode must be locked on entry and exit.
 819  Returns -1 on error, or number of share modes on success (may be zero).
 820 ****************************************************************************/
 821
 822 static NTSTATUS open_mode_check(connection_struct *conn,
 823                                 struct share_mode_lock *lck,
 824                                 uint32 access_mask,
 825                                 uint32 share_access,
 826                                 uint32 create_options,
 827                                 bool *file_existed)
 828 {
 829         int i;
 830
 831         if(lck->num_share_modes == 0) {
 832                 return NT_STATUS_OK;
 833         }
 834
 835         *file_existed = True;
 836
 837         /* A delete on close prohibits everything */
 838
 839         if (lck->delete_on_close) {
 840                 return NT_STATUS_DELETE_PENDING;
 841         }
 842
 843         if (is_stat_open(access_mask)) {
 844                 /* Stat open that doesn't trigger oplock breaks or share mode
 845                  * checks... ! JRA. */
 846                 return NT_STATUS_OK;
 847         }
 848
 849         /*
 850          * Check if the share modes will give us access.
 851          */
 852
 853 #if defined(DEVELOPER)
 854         for(i = 0; i < lck->num_share_modes; i++) {
 855                 validate_my_share_entries(i, &lck->share_modes[i]);
 856         }
 857 #endif
 858
 859         if (!lp_share_modes(SNUM(conn))) {
 860                 return NT_STATUS_OK;
 861         }
 862
 863         /* Now we check the share modes, after any oplock breaks. */
 864         for(i = 0; i < lck->num_share_modes; i++) {
 865
 866                 if (!is_valid_share_mode_entry(&lck->share_modes[i])) {
 867                         continue;
 868                 }
 869
 870                 /* someone else has a share lock on it, check to see if we can
 871                  * too */
 872                 if (share_conflict(&lck->share_modes[i],
 873                                    access_mask, share_access)) {
 874                         return NT_STATUS_SHARING_VIOLATION;
 875                 }
 876         }
 877
 878         return NT_STATUS_OK;
 879 }
 880
 881 static bool is_delete_request(files_struct *fsp) {
 882         return ((fsp->access_mask == DELETE_ACCESS) &&
 883                 (fsp->oplock_type == NO_OPLOCK));
 884 }
 885
 886 /*
 887  * Send a break message to the oplock holder and delay the open for
 888  * our client.
 889  */
 890
 891 static NTSTATUS send_break_message(files_struct *fsp,
 892                                         struct share_mode_entry *exclusive,
 893                                         uint16 mid,
 894                                         int oplock_request)
 895 {
 896         NTSTATUS status;
 897         char msg[MSG_SMB_SHARE_MODE_ENTRY_SIZE];
 898
 899         DEBUG(10, ("Sending break request to PID %s\n",
 900                    procid_str_static(&exclusive->pid)));
 901         exclusive->op_mid = mid;
 902
 903         /* Create the message. */
 904         share_mode_entry_to_message(msg, exclusive);
 905
 906         /* Add in the FORCE_OPLOCK_BREAK_TO_NONE bit in the message if set. We
 907            don't want this set in the share mode struct pointed to by lck. */
 908
 909         if (oplock_request & FORCE_OPLOCK_BREAK_TO_NONE) {
 910                 SSVAL(msg,6,exclusive->op_type | FORCE_OPLOCK_BREAK_TO_NONE);
 911         }
 912
 913         status = messaging_send_buf(smbd_messaging_context(), exclusive->pid,
 914                                     MSG_SMB_BREAK_REQUEST,
 915                                     (uint8 *)msg,
 916                                     MSG_SMB_SHARE_MODE_ENTRY_SIZE);
 917         if (!NT_STATUS_IS_OK(status)) {
 918                 DEBUG(3, ("Could not send oplock break message: %s\n",
 919                           nt_errstr(status)));
 920         }
 921
 922         return status;
 923 }
 924
 925 /*
 926  * 1) No files open at all or internal open: Grant whatever the client wants.
 927  *
 928  * 2) Exclusive (or batch) oplock around: If the requested access is a delete
 929  *    request, break if the oplock around is a batch oplock. If it's another
 930  *    requested access type, break.
 931  *
 932  * 3) Only level2 around: Grant level2 and do nothing else.
 933  */
 934
 935 static bool delay_for_oplocks(struct share_mode_lock *lck,
 936                               files_struct *fsp,
 937                               uint16 mid,
 938                               int pass_number,
 939                               int oplock_request)
 940 {
 941         int i;
 942         struct share_mode_entry *exclusive = NULL;
 943         bool valid_entry = false;
 944         bool have_level2 = false;
 945         bool have_a_none_oplock = false;
 946         bool allow_level2 = (global_client_caps & CAP_LEVEL_II_OPLOCKS) &&
 947                             lp_level2_oplocks(SNUM(fsp->conn));
 948
 949         if (oplock_request & INTERNAL_OPEN_ONLY) {
 950                 fsp->oplock_type = NO_OPLOCK;
 951         }
 952
 953         if ((oplock_request & INTERNAL_OPEN_ONLY) || is_stat_open(fsp->access_mask)) {
 954                 return false;
 955         }
 956
 957         for (i=0; i<lck->num_share_modes; i++) {
 958
 959                 if (!is_valid_share_mode_entry(&lck->share_modes[i])) {
 960                         continue;
 961                 }
 962
 963                 /* At least one entry is not an invalid or deferred entry. */
 964                 valid_entry = true;
 965
 966                 if (pass_number == 1) {
 967                         if (BATCH_OPLOCK_TYPE(lck->share_modes[i].op_type)) {
 968                                 SMB_ASSERT(exclusive == NULL);
 969                                 exclusive = &lck->share_modes[i];
 970                         }
 971                 } else {
 972                         if (EXCLUSIVE_OPLOCK_TYPE(lck->share_modes[i].op_type)) {
 973                                 SMB_ASSERT(exclusive == NULL);
 974                                 exclusive = &lck->share_modes[i];
 975                         }
 976                 }
 977
 978                 if (LEVEL_II_OPLOCK_TYPE(lck->share_modes[i].op_type)) {
 979                         SMB_ASSERT(exclusive == NULL);
 980                         have_level2 = true;
 981                 }
 982
 983                 if (lck->share_modes[i].op_type == NO_OPLOCK) {
 984                         have_a_none_oplock = true;
 985                 }
 986         }
 987
 988         if (exclusive != NULL) { /* Found an exclusive oplock */
 989                 bool delay_it = is_delete_request(fsp) ?
 990                                 BATCH_OPLOCK_TYPE(exclusive->op_type) : true;
 991                 SMB_ASSERT(!have_level2);
 992                 if (delay_it) {
 993                         send_break_message(fsp, exclusive, mid, oplock_request);
 994                         return true;
 995                 }
 996         }
 997
 998         /*
 999          * Match what was requested (fsp->oplock_type) with
1000          * what was found in the existing share modes.
1001          */
1002
1003         if (!valid_entry) {
1004                 /* All entries are placeholders or deferred.
1005                  * Directly grant whatever the client wants. */
1006                 if (fsp->oplock_type == NO_OPLOCK) {
1007                         /* Store a level2 oplock, but don't tell the client */
1008                         fsp->oplock_type = FAKE_LEVEL_II_OPLOCK;
1009                 }
1010         } else if (have_a_none_oplock) {
1011                 fsp->oplock_type = NO_OPLOCK;
1012         } else if (have_level2) {
1013                 if (fsp->oplock_type == NO_OPLOCK ||
1014                                 fsp->oplock_type == FAKE_LEVEL_II_OPLOCK) {
1015                         /* Store a level2 oplock, but don't tell the client */
1016                         fsp->oplock_type = FAKE_LEVEL_II_OPLOCK;
1017                 } else {
1018                         fsp->oplock_type = LEVEL_II_OPLOCK;
1019                 }
1020         } else {
1021                 /* This case can never happen. */
1022                 SMB_ASSERT(1);
1023         }
1024
1025         /*
1026          * Don't grant level2 to clients that don't want them
1027          * or if we've turned them off.
1028          */
1029         if (fsp->oplock_type == LEVEL_II_OPLOCK && !allow_level2) {
1030                 fsp->oplock_type = FAKE_LEVEL_II_OPLOCK;
1031         }
1032
1033         DEBUG(10,("delay_for_oplocks: oplock type 0x%x on file %s\n",
1034                   fsp->oplock_type, fsp_str_dbg(fsp)));
1035
1036         /* No delay. */
1037         return false;
1038 }
1039
1040 bool request_timed_out(struct timeval request_time,
1041                        struct timeval timeout)
1042 {
1043         struct timeval now, end_time;
1044         GetTimeOfDay(&now);
1045         end_time = timeval_sum(&request_time, &timeout);
1046         return (timeval_compare(&end_time, &now) < 0);
1047 }
1048
1049 /****************************************************************************
1050  Handle the 1 second delay in returning a SHARING_VIOLATION error.
1051 ****************************************************************************/
1052
1053 static void defer_open(struct share_mode_lock *lck,
1054                        struct timeval request_time,
1055                        struct timeval timeout,
1056                        struct smb_request *req,
1057                        struct deferred_open_record *state)
1058 {
1059         int i;
1060
1061         /* Paranoia check */
1062
1063         for (i=0; i<lck->num_share_modes; i++) {
1064                 struct share_mode_entry *e = &lck->share_modes[i];
1065
1066                 if (!is_deferred_open_entry(e)) {
1067                         continue;
1068                 }
1069
1070                 if (procid_is_me(&e->pid) && (e->op_mid == req->mid)) {
1071                         DEBUG(0, ("Trying to defer an already deferred "
1072                                   "request: mid=%d, exiting\n", req->mid));
1073                         exit_server("attempt to defer a deferred request");
1074                 }
1075         }
1076
1077         /* End paranoia check */
1078
1079         DEBUG(10,("defer_open_sharing_error: time [%u.%06u] adding deferred "
1080                   "open entry for mid %u\n",
1081                   (unsigned int)request_time.tv_sec,
1082                   (unsigned int)request_time.tv_usec,
1083                   (unsigned int)req->mid));
1084
1085         if (!push_deferred_smb_message(req, request_time, timeout,
1086                                        (char *)state, sizeof(*state))) {
1087                 exit_server("push_deferred_smb_message failed");
1088         }
1089         add_deferred_open(lck, req->mid, request_time, state->id);
1090 }
1091
1092
1093 /****************************************************************************
1094  On overwrite open ensure that the attributes match.
1095 ****************************************************************************/
1096
1097 bool open_match_attributes(connection_struct *conn,
1098                            uint32 old_dos_attr,
1099                            uint32 new_dos_attr,
1100                            mode_t existing_unx_mode,
1101                            mode_t new_unx_mode,
1102                            mode_t *returned_unx_mode)
1103 {
1104         uint32 noarch_old_dos_attr, noarch_new_dos_attr;
1105
1106         noarch_old_dos_attr = (old_dos_attr & ~FILE_ATTRIBUTE_ARCHIVE);
1107         noarch_new_dos_attr = (new_dos_attr & ~FILE_ATTRIBUTE_ARCHIVE);
1108
1109         if((noarch_old_dos_attr == 0 && noarch_new_dos_attr != 0) ||
1110            (noarch_old_dos_attr != 0 && ((noarch_old_dos_attr & noarch_new_dos_attr) == noarch_old_dos_attr))) {
1111                 *returned_unx_mode = new_unx_mode;
1112         } else {
1113                 *returned_unx_mode = (mode_t)0;
1114         }
1115
1116         DEBUG(10,("open_match_attributes: old_dos_attr = 0x%x, "
1117                   "existing_unx_mode = 0%o, new_dos_attr = 0x%x "
1118                   "returned_unx_mode = 0%o\n",
1119                   (unsigned int)old_dos_attr,
1120                   (unsigned int)existing_unx_mode,
1121                   (unsigned int)new_dos_attr,
1122                   (unsigned int)*returned_unx_mode ));
1123
1124         /* If we're mapping SYSTEM and HIDDEN ensure they match. */
1125         if (lp_map_system(SNUM(conn)) || lp_store_dos_attributes(SNUM(conn))) {
1126                 if ((old_dos_attr & FILE_ATTRIBUTE_SYSTEM) &&
1127                     !(new_dos_attr & FILE_ATTRIBUTE_SYSTEM)) {
1128                         return False;
1129                 }
1130         }
1131         if (lp_map_hidden(SNUM(conn)) || lp_store_dos_attributes(SNUM(conn))) {
1132                 if ((old_dos_attr & FILE_ATTRIBUTE_HIDDEN) &&
1133                     !(new_dos_attr & FILE_ATTRIBUTE_HIDDEN)) {
1134                         return False;
1135                 }
1136         }
1137         return True;
1138 }
1139
1140 /****************************************************************************
1141  Special FCB or DOS processing in the case of a sharing violation.
1142  Try and find a duplicated file handle.
1143 ****************************************************************************/
1144
1145 NTSTATUS fcb_or_dos_open(struct smb_request *req,
1146                                      connection_struct *conn,
1147                                      files_struct *fsp_to_dup_into,
1148                                      const struct smb_filename *smb_fname,
1149                                      struct file_id id,
1150                                      uint16 file_pid,
1151                                      uint16 vuid,
1152                                      uint32 access_mask,
1153                                      uint32 share_access,
1154                                      uint32 create_options)
1155 {
1156         files_struct *fsp;
1157
1158         DEBUG(5,("fcb_or_dos_open: attempting old open semantics for "
1159                  "file %s.\n", smb_fname_str_dbg(smb_fname)));
1160
1161         for(fsp = file_find_di_first(id); fsp;
1162             fsp = file_find_di_next(fsp)) {
1163
1164                 DEBUG(10,("fcb_or_dos_open: checking file %s, fd = %d, "
1165                           "vuid = %u, file_pid = %u, private_options = 0x%x "
1166                           "access_mask = 0x%x\n", fsp_str_dbg(fsp),
1167                           fsp->fh->fd, (unsigned int)fsp->vuid,
1168                           (unsigned int)fsp->file_pid,
1169                           (unsigned int)fsp->fh->private_options,
1170                           (unsigned int)fsp->access_mask ));
1171
1172                 if (fsp->fh->fd != -1 &&
1173                     fsp->vuid == vuid &&
1174                     fsp->file_pid == file_pid &&
1175                     (fsp->fh->private_options & (NTCREATEX_OPTIONS_PRIVATE_DENY_DOS |
1176                                                  NTCREATEX_OPTIONS_PRIVATE_DENY_FCB)) &&
1177                     (fsp->access_mask & FILE_WRITE_DATA) &&
1178                     strequal(fsp->fsp_name->base_name, smb_fname->base_name) &&
1179                     strequal(fsp->fsp_name->stream_name,
1180                              smb_fname->stream_name)) {
1181                         DEBUG(10,("fcb_or_dos_open: file match\n"));
1182                         break;
1183                 }
1184         }
1185
1186         if (!fsp) {
1187                 return NT_STATUS_NOT_FOUND;
1188         }
1189
1190         /* quite an insane set of semantics ... */
1191         if (is_executable(smb_fname->base_name) &&
1192             (fsp->fh->private_options & NTCREATEX_OPTIONS_PRIVATE_DENY_DOS)) {
1193                 DEBUG(10,("fcb_or_dos_open: file fail due to is_executable.\n"));
1194                 return NT_STATUS_INVALID_PARAMETER;
1195         }
1196
1197         /* We need to duplicate this fsp. */
1198         return dup_file_fsp(req, fsp, access_mask, share_access,
1199                             create_options, fsp_to_dup_into);
1200 }
1201
1202 /****************************************************************************
1203  Open a file with a share mode - old openX method - map into NTCreate.
1204 ****************************************************************************/
1205
1206 bool map_open_params_to_ntcreate(const struct smb_filename *smb_fname,
1207                                  int deny_mode, int open_func,
1208                                  uint32 *paccess_mask,
1209                                  uint32 *pshare_mode,
1210                                  uint32 *pcreate_disposition,
1211                                  uint32 *pcreate_options)
1212 {
1213         uint32 access_mask;
1214         uint32 share_mode;
1215         uint32 create_disposition;
1216         uint32 create_options = FILE_NON_DIRECTORY_FILE;
1217
1218         DEBUG(10,("map_open_params_to_ntcreate: fname = %s, deny_mode = 0x%x, "
1219                   "open_func = 0x%x\n",
1220                   smb_fname_str_dbg(smb_fname), (unsigned int)deny_mode,
1221                   (unsigned int)open_func ));
1222
1223         /* Create the NT compatible access_mask. */
1224         switch (GET_OPENX_MODE(deny_mode)) {
1225                 case DOS_OPEN_EXEC: /* Implies read-only - used to be FILE_READ_DATA */
1226                 case DOS_OPEN_RDONLY:
1227                         access_mask = FILE_GENERIC_READ;
1228                         break;
1229                 case DOS_OPEN_WRONLY:
1230                         access_mask = FILE_GENERIC_WRITE;
1231                         break;
1232                 case DOS_OPEN_RDWR:
1233                 case DOS_OPEN_FCB:
1234                         access_mask = FILE_GENERIC_READ|FILE_GENERIC_WRITE;
1235                         break;
1236                 default:
1237                         DEBUG(10,("map_open_params_to_ntcreate: bad open mode = 0x%x\n",
1238                                   (unsigned int)GET_OPENX_MODE(deny_mode)));
1239                         return False;
1240         }
1241
1242         /* Create the NT compatible create_disposition. */
1243         switch (open_func) {
1244                 case OPENX_FILE_EXISTS_FAIL|OPENX_FILE_CREATE_IF_NOT_EXIST:
1245                         create_disposition = FILE_CREATE;
1246                         break;
1247
1248                 case OPENX_FILE_EXISTS_OPEN:
1249                         create_disposition = FILE_OPEN;
1250                         break;
1251
1252                 case OPENX_FILE_EXISTS_OPEN|OPENX_FILE_CREATE_IF_NOT_EXIST:
1253                         create_disposition = FILE_OPEN_IF;
1254                         break;
1255
1256                 case OPENX_FILE_EXISTS_TRUNCATE:
1257                         create_disposition = FILE_OVERWRITE;
1258                         break;
1259
1260                 case OPENX_FILE_EXISTS_TRUNCATE|OPENX_FILE_CREATE_IF_NOT_EXIST:
1261                         create_disposition = FILE_OVERWRITE_IF;
1262                         break;
1263
1264                 default:
1265                         /* From samba4 - to be confirmed. */
1266                         if (GET_OPENX_MODE(deny_mode) == DOS_OPEN_EXEC) {
1267                                 create_disposition = FILE_CREATE;
1268                                 break;
1269                         }
1270                         DEBUG(10,("map_open_params_to_ntcreate: bad "
1271                                   "open_func 0x%x\n", (unsigned int)open_func));
1272                         return False;
1273         }
1274
1275         /* Create the NT compatible share modes. */
1276         switch (GET_DENY_MODE(deny_mode)) {
1277                 case DENY_ALL:
1278                         share_mode = FILE_SHARE_NONE;
1279                         break;
1280
1281                 case DENY_WRITE:
1282                         share_mode = FILE_SHARE_READ;
1283                         break;
1284
1285                 case DENY_READ:
1286                         share_mode = FILE_SHARE_WRITE;
1287                         break;
1288
1289                 case DENY_NONE:
1290                         share_mode = FILE_SHARE_READ|FILE_SHARE_WRITE;
1291                         break;
1292
1293                 case DENY_DOS:
1294                         create_options |= NTCREATEX_OPTIONS_PRIVATE_DENY_DOS;
1295                         if (is_executable(smb_fname->base_name)) {
1296                                 share_mode = FILE_SHARE_READ|FILE_SHARE_WRITE;
1297                         } else {
1298                                 if (GET_OPENX_MODE(deny_mode) == DOS_OPEN_RDONLY) {
1299                                         share_mode = FILE_SHARE_READ;
1300                                 } else {
1301                                         share_mode = FILE_SHARE_NONE;
1302                                 }
1303                         }
1304                         break;
1305
1306                 case DENY_FCB:
1307                         create_options |= NTCREATEX_OPTIONS_PRIVATE_DENY_FCB;
1308                         share_mode = FILE_SHARE_NONE;
1309                         break;
1310
1311                 default:
1312                         DEBUG(10,("map_open_params_to_ntcreate: bad deny_mode 0x%x\n",
1313                                 (unsigned int)GET_DENY_MODE(deny_mode) ));
1314                         return False;
1315         }
1316
1317         DEBUG(10,("map_open_params_to_ntcreate: file %s, access_mask = 0x%x, "
1318                   "share_mode = 0x%x, create_disposition = 0x%x, "
1319                   "create_options = 0x%x\n",
1320                   smb_fname_str_dbg(smb_fname),
1321                   (unsigned int)access_mask,
1322                   (unsigned int)share_mode,
1323                   (unsigned int)create_disposition,
1324                   (unsigned int)create_options ));
1325
1326         if (paccess_mask) {
1327                 *paccess_mask = access_mask;
1328         }
1329         if (pshare_mode) {
1330                 *pshare_mode = share_mode;
1331         }
1332         if (pcreate_disposition) {
1333                 *pcreate_disposition = create_disposition;
1334         }
1335         if (pcreate_options) {
1336                 *pcreate_options = create_options;
1337         }
1338
1339         return True;
1340
1341 }
1342
1343 static void schedule_defer_open(struct share_mode_lock *lck,
1344                                 struct timeval request_time,
1345                                 struct smb_request *req)
1346 {
1347         struct deferred_open_record state;
1348
1349         /* This is a relative time, added to the absolute
1350            request_time value to get the absolute timeout time.
1351            Note that if this is the second or greater time we enter
1352            this codepath for this particular request mid then
1353            request_time is left as the absolute time of the *first*
1354            time this request mid was processed. This is what allows
1355            the request to eventually time out. */
1356
1357         struct timeval timeout;
1358
1359         /* Normally the smbd we asked should respond within
1360          * OPLOCK_BREAK_TIMEOUT seconds regardless of whether
1361          * the client did, give twice the timeout as a safety
1362          * measure here in case the other smbd is stuck
1363          * somewhere else. */
1364
1365         timeout = timeval_set(OPLOCK_BREAK_TIMEOUT*2, 0);
1366
1367         /* Nothing actually uses state.delayed_for_oplocks
1368            but it's handy to differentiate in debug messages
1369            between a 30 second delay due to oplock break, and
1370            a 1 second delay for share mode conflicts. */
1371
1372         state.delayed_for_oplocks = True;
1373         state.id = lck->id;
1374
1375         if (!request_timed_out(request_time, timeout)) {
1376                 defer_open(lck, request_time, timeout, req, &state);
1377         }
1378 }
1379
1380 /****************************************************************************
1381  Work out what access_mask to use from what the client sent us.
1382 ****************************************************************************/
1383
1384 static NTSTATUS calculate_access_mask(connection_struct *conn,
1385                                         const struct smb_filename *smb_fname,
1386                                         bool file_existed,
1387                                         uint32_t access_mask,
1388                                         uint32_t *access_mask_out)
1389 {
1390         NTSTATUS status;
1391
1392         /*
1393          * Convert GENERIC bits to specific bits.
1394          */
1395
1396         se_map_generic(&access_mask, &file_generic_mapping);
1397
1398         /* Calculate MAXIMUM_ALLOWED_ACCESS if requested. */
1399         if (access_mask & MAXIMUM_ALLOWED_ACCESS) {
1400                 if (file_existed) {
1401
1402                         struct security_descriptor *sd;
1403                         uint32_t access_granted = 0;
1404
1405                         status = SMB_VFS_GET_NT_ACL(conn, smb_fname->base_name,
1406                                         (OWNER_SECURITY_INFORMATION |
1407                                         GROUP_SECURITY_INFORMATION |
1408                                         DACL_SECURITY_INFORMATION),&sd);
1409
1410                         if (!NT_STATUS_IS_OK(status)) {
1411                                 DEBUG(10, ("calculate_access_mask: Could not get acl "
1412                                         "on file %s: %s\n",
1413                                         smb_fname_str_dbg(smb_fname),
1414                                         nt_errstr(status)));
1415                                 return NT_STATUS_ACCESS_DENIED;
1416                         }
1417
1418                         status = smb1_file_se_access_check(conn,
1419                                         sd,
1420                                         conn->server_info->ptok,
1421                                         access_mask,
1422                                         &access_granted);
1423
1424                         TALLOC_FREE(sd);
1425
1426                         if (!NT_STATUS_IS_OK(status)) {
1427                                 DEBUG(10, ("calculate_access_mask: Access denied on "
1428                                         "file %s: when calculating maximum access\n",
1429                                         smb_fname_str_dbg(smb_fname)));
1430                                 return NT_STATUS_ACCESS_DENIED;
1431                         }
1432
1433                         access_mask = access_granted;
1434                 } else {
1435                         access_mask = FILE_GENERIC_ALL;
1436                 }
1437         }
1438
1439         *access_mask_out = access_mask;
1440         return NT_STATUS_OK;
1441 }
1442
1443 /****************************************************************************
1444  Open a file with a share mode. Passed in an already created files_struct *.
1445 ****************************************************************************/
1446
1447 static NTSTATUS open_file_ntcreate(connection_struct *conn,
1448                             struct smb_request *req,
1449                             uint32 access_mask,         /* access bits (FILE_READ_DATA etc.) */
1450                             uint32 share_access,        /* share constants (FILE_SHARE_READ etc) */
1451                             uint32 create_disposition,  /* FILE_OPEN_IF etc. */
1452                             uint32 create_options,      /* options such as delete on close. */
1453                             uint32 new_dos_attributes,  /* attributes used for new file. */
1454                             int oplock_request,         /* internal Samba oplock codes. */
1455                                                         /* Information (FILE_EXISTS etc.) */
1456                             int *pinfo,
1457                             files_struct *fsp)
1458 {
1459         struct smb_filename *smb_fname = fsp->fsp_name;
1460         int flags=0;
1461         int flags2=0;
1462         bool file_existed = VALID_STAT(smb_fname->st);
1463         bool def_acl = False;
1464         bool posix_open = False;
1465         bool new_file_created = False;
1466         bool clear_ads = false;
1467         struct file_id id;
1468         NTSTATUS fsp_open = NT_STATUS_ACCESS_DENIED;
1469         mode_t new_unx_mode = (mode_t)0;
1470         mode_t unx_mode = (mode_t)0;
1471         int info;
1472         uint32 existing_dos_attributes = 0;
1473         struct pending_message_list *pml = NULL;
1474         struct timeval request_time = timeval_zero();
1475         struct share_mode_lock *lck = NULL;
1476         uint32 open_access_mask = access_mask;
1477         NTSTATUS status;
1478         char *parent_dir;
1479
1480         ZERO_STRUCT(id);
1481
1482         /* Windows allows a new file to be created and
1483            silently removes a FILE_ATTRIBUTE_DIRECTORY
1484            sent by the client. Do the same. */
1485
1486         new_dos_attributes &= ~FILE_ATTRIBUTE_DIRECTORY;
1487
1488         if (conn->printer) {
1489                 /*
1490                  * Printers are handled completely differently.
1491                  * Most of the passed parameters are ignored.
1492                  */
1493
1494                 if (pinfo) {
1495                         *pinfo = FILE_WAS_CREATED;
1496                 }
1497
1498                 DEBUG(10, ("open_file_ntcreate: printer open fname=%s\n",
1499                            smb_fname_str_dbg(smb_fname)));
1500
1501                 if (!req) {
1502                         DEBUG(0,("open_file_ntcreate: printer open without "
1503                                 "an SMB request!\n"));
1504                         return NT_STATUS_INTERNAL_ERROR;
1505                 }
1506
1507                 return print_fsp_open(req, conn, smb_fname->base_name,
1508                                       req->vuid, fsp);
1509         }
1510
1511         if (!parent_dirname(talloc_tos(), smb_fname->base_name, &parent_dir,
1512                             NULL)) {
1513                 return NT_STATUS_NO_MEMORY;
1514         }
1515
1516         if (new_dos_attributes & FILE_FLAG_POSIX_SEMANTICS) {
1517                 posix_open = True;
1518                 unx_mode = (mode_t)(new_dos_attributes & ~FILE_FLAG_POSIX_SEMANTICS);
1519                 new_dos_attributes = 0;
1520         } else {
1521                 /* We add aARCH to this as this mode is only used if the file is
1522                  * created new. */
1523                 unx_mode = unix_mode(conn, new_dos_attributes | aARCH,
1524                                      smb_fname, parent_dir);
1525         }
1526
1527         DEBUG(10, ("open_file_ntcreate: fname=%s, dos_attrs=0x%x "
1528                    "access_mask=0x%x share_access=0x%x "
1529                    "create_disposition = 0x%x create_options=0x%x "
1530                    "unix mode=0%o oplock_request=%d\n",
1531                    smb_fname_str_dbg(smb_fname), new_dos_attributes,
1532                    access_mask, share_access, create_disposition,
1533                    create_options, (unsigned int)unx_mode, oplock_request));
1534
1535         if ((req == NULL) && ((oplock_request & INTERNAL_OPEN_ONLY) == 0)) {
1536                 DEBUG(0, ("No smb request but not an internal only open!\n"));
1537                 return NT_STATUS_INTERNAL_ERROR;
1538         }
1539
1540         /*
1541          * Only non-internal opens can be deferred at all
1542          */
1543
1544         if ((req != NULL)
1545             && ((pml = get_open_deferred_message(req->mid)) != NULL)) {
1546                 struct deferred_open_record *state =
1547                         (struct deferred_open_record *)pml->private_data.data;
1548
1549                 /* Remember the absolute time of the original
1550                    request with this mid. We'll use it later to
1551                    see if this has timed out. */
1552
1553                 request_time = pml->request_time;
1554
1555                 /* Remove the deferred open entry under lock. */
1556                 lck = get_share_mode_lock(talloc_tos(), state->id, NULL, NULL,
1557                                           NULL);
1558                 if (lck == NULL) {
1559                         DEBUG(0, ("could not get share mode lock\n"));
1560                 } else {
1561                         del_deferred_open_entry(lck, req->mid);
1562                         TALLOC_FREE(lck);
1563                 }
1564
1565                 /* Ensure we don't reprocess this message. */
1566                 remove_deferred_open_smb_message(req->mid);
1567         }
1568
1569         status = check_name(conn, smb_fname->base_name);
1570         if (!NT_STATUS_IS_OK(status)) {
1571                 return status;
1572         }
1573
1574         if (!posix_open) {
1575                 new_dos_attributes &= SAMBA_ATTRIBUTES_MASK;
1576                 if (file_existed) {
1577                         existing_dos_attributes = dos_mode(conn, smb_fname);
1578                 }
1579         }
1580
1581         /* ignore any oplock requests if oplocks are disabled */
1582         if (!lp_oplocks(SNUM(conn)) || global_client_failed_oplock_break ||
1583             IS_VETO_OPLOCK_PATH(conn, smb_fname->base_name)) {
1584                 /* Mask off everything except the private Samba bits. */
1585                 oplock_request &= SAMBA_PRIVATE_OPLOCK_MASK;
1586         }
1587
1588         /* this is for OS/2 long file names - say we don't support them */
1589         if (!lp_posix_pathnames() && strstr(smb_fname->base_name,".+,;=[].")) {
1590                 /* OS/2 Workplace shell fix may be main code stream in a later
1591                  * release. */
1592                 DEBUG(5,("open_file_ntcreate: OS/2 long filenames are not "
1593                          "supported.\n"));
1594                 if (use_nt_status()) {
1595                         return NT_STATUS_OBJECT_NAME_NOT_FOUND;
1596                 }
1597                 return NT_STATUS_DOS(ERRDOS, ERRcannotopen);
1598         }
1599
1600         switch( create_disposition ) {
1601                 /*
1602                  * Currently we're using FILE_SUPERSEDE as the same as
1603                  * FILE_OVERWRITE_IF but they really are
1604                  * different. FILE_SUPERSEDE deletes an existing file
1605                  * (requiring delete access) then recreates it.
1606                  */
1607                 case FILE_SUPERSEDE:
1608                         /* If file exists replace/overwrite. If file doesn't
1609                          * exist create. */
1610                         flags2 |= (O_CREAT | O_TRUNC);
1611                         clear_ads = true;
1612                         break;
1613
1614                 case FILE_OVERWRITE_IF:
1615                         /* If file exists replace/overwrite. If file doesn't
1616                          * exist create. */
1617                         flags2 |= (O_CREAT | O_TRUNC);
1618                         clear_ads = true;
1619                         break;
1620
1621                 case FILE_OPEN:
1622                         /* If file exists open. If file doesn't exist error. */
1623                         if (!file_existed) {
1624                                 DEBUG(5,("open_file_ntcreate: FILE_OPEN "
1625                                          "requested for file %s and file "
1626                                          "doesn't exist.\n",
1627                                          smb_fname_str_dbg(smb_fname)));
1628                                 errno = ENOENT;
1629                                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
1630                         }
1631                         break;
1632
1633                 case FILE_OVERWRITE:
1634                         /* If file exists overwrite. If file doesn't exist
1635                          * error. */
1636                         if (!file_existed) {
1637                                 DEBUG(5,("open_file_ntcreate: FILE_OVERWRITE "
1638                                          "requested for file %s and file "
1639                                          "doesn't exist.\n",
1640                                          smb_fname_str_dbg(smb_fname) ));
1641                                 errno = ENOENT;
1642                                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
1643                         }
1644                         flags2 |= O_TRUNC;
1645                         clear_ads = true;
1646                         break;
1647
1648                 case FILE_CREATE:
1649                         /* If file exists error. If file doesn't exist
1650                          * create. */
1651                         if (file_existed) {
1652                                 DEBUG(5,("open_file_ntcreate: FILE_CREATE "
1653                                          "requested for file %s and file "
1654                                          "already exists.\n",
1655                                          smb_fname_str_dbg(smb_fname)));
1656                                 if (S_ISDIR(smb_fname->st.st_ex_mode)) {
1657                                         errno = EISDIR;
1658                                 } else {
1659                                         errno = EEXIST;
1660                                 }
1661                                 return map_nt_error_from_unix(errno);
1662                         }
1663                         flags2 |= (O_CREAT|O_EXCL);
1664                         break;
1665
1666                 case FILE_OPEN_IF:
1667                         /* If file exists open. If file doesn't exist
1668                          * create. */
1669                         flags2 |= O_CREAT;
1670                         break;
1671
1672                 default:
1673                         return NT_STATUS_INVALID_PARAMETER;
1674         }
1675
1676         /* We only care about matching attributes on file exists and
1677          * overwrite. */
1678
1679         if (!posix_open && file_existed && ((create_disposition == FILE_OVERWRITE) ||
1680                              (create_disposition == FILE_OVERWRITE_IF))) {
1681                 if (!open_match_attributes(conn, existing_dos_attributes,
1682                                            new_dos_attributes,
1683                                            smb_fname->st.st_ex_mode,
1684                                            unx_mode, &new_unx_mode)) {
1685                         DEBUG(5,("open_file_ntcreate: attributes missmatch "
1686                                  "for file %s (%x %x) (0%o, 0%o)\n",
1687                                  smb_fname_str_dbg(smb_fname),
1688                                  existing_dos_attributes,
1689                                  new_dos_attributes,
1690                                  (unsigned int)smb_fname->st.st_ex_mode,
1691                                  (unsigned int)unx_mode ));
1692                         errno = EACCES;
1693                         return NT_STATUS_ACCESS_DENIED;
1694                 }
1695         }
1696
1697         status = calculate_access_mask(conn, smb_fname, file_existed,
1698                                         access_mask,
1699                                         &access_mask);
1700         if (!NT_STATUS_IS_OK(status)) {
1701                 DEBUG(10, ("open_file_ntcreate: calculate_access_mask "
1702                         "on file %s returned %s\n",
1703                         smb_fname_str_dbg(smb_fname), nt_errstr(status)));
1704                 return status;
1705         }
1706
1707         open_access_mask = access_mask;
1708
1709         if ((flags2 & O_TRUNC) || (oplock_request & FORCE_OPLOCK_BREAK_TO_NONE)) {
1710                 open_access_mask |= FILE_WRITE_DATA; /* This will cause oplock breaks. */
1711         }
1712
1713         DEBUG(10, ("open_file_ntcreate: fname=%s, after mapping "
1714                    "access_mask=0x%x\n", smb_fname_str_dbg(smb_fname),
1715                     access_mask));
1716
1717         /*
1718          * Note that we ignore the append flag as append does not
1719          * mean the same thing under DOS and Unix.
1720          */
1721
1722         if ((access_mask & (FILE_WRITE_DATA | FILE_APPEND_DATA)) ||
1723                         (oplock_request & FORCE_OPLOCK_BREAK_TO_NONE)) {
1724                 /* DENY_DOS opens are always underlying read-write on the
1725                    file handle, no matter what the requested access mask
1726                     says. */
1727                 if ((create_options & NTCREATEX_OPTIONS_PRIVATE_DENY_DOS) ||
1728                         access_mask & (FILE_READ_ATTRIBUTES|FILE_READ_DATA|FILE_READ_EA|FILE_EXECUTE)) {
1729                         flags = O_RDWR;
1730                 } else {
1731                         flags = O_WRONLY;
1732                 }
1733         } else {
1734                 flags = O_RDONLY;
1735         }
1736
1737         /*
1738          * Currently we only look at FILE_WRITE_THROUGH for create options.
1739          */
1740
1741 #if defined(O_SYNC)
1742         if ((create_options & FILE_WRITE_THROUGH) && lp_strict_sync(SNUM(conn))) {
1743                 flags2 |= O_SYNC;
1744         }
1745 #endif /* O_SYNC */
1746
1747         if (posix_open && (access_mask & FILE_APPEND_DATA)) {
1748                 flags2 |= O_APPEND;
1749         }
1750
1751         if (!posix_open && !CAN_WRITE(conn)) {
1752                 /*
1753                  * We should really return a permission denied error if either
1754                  * O_CREAT or O_TRUNC are set, but for compatibility with
1755                  * older versions of Samba we just AND them out.
1756                  */
1757                 flags2 &= ~(O_CREAT|O_TRUNC);
1758         }
1759
1760         /*
1761          * Ensure we can't write on a read-only share or file.
1762          */
1763
1764         if (flags != O_RDONLY && file_existed &&
1765             (!CAN_WRITE(conn) || IS_DOS_READONLY(existing_dos_attributes))) {
1766                 DEBUG(5,("open_file_ntcreate: write access requested for "
1767                          "file %s on read only %s\n",
1768                          smb_fname_str_dbg(smb_fname),
1769                          !CAN_WRITE(conn) ? "share" : "file" ));
1770                 errno = EACCES;
1771                 return NT_STATUS_ACCESS_DENIED;
1772         }
1773
1774         fsp->file_id = vfs_file_id_from_sbuf(conn, &smb_fname->st);
1775         fsp->share_access = share_access;
1776         fsp->fh->private_options = create_options;
1777         fsp->access_mask = open_access_mask; /* We change this to the
1778                                               * requested access_mask after
1779                                               * the open is done. */
1780         fsp->posix_open = posix_open;
1781
1782         /* Ensure no SAMBA_PRIVATE bits can be set. */
1783         fsp->oplock_type = (oplock_request & ~SAMBA_PRIVATE_OPLOCK_MASK);
1784
1785         if (timeval_is_zero(&request_time)) {
1786                 request_time = fsp->open_time;
1787         }
1788
1789         if (file_existed) {
1790                 struct timespec old_write_time = smb_fname->st.st_ex_mtime;
1791                 id = vfs_file_id_from_sbuf(conn, &smb_fname->st);
1792
1793                 lck = get_share_mode_lock(talloc_tos(), id,
1794                                           conn->connectpath,
1795                                           smb_fname, &old_write_time);
1796
1797                 if (lck == NULL) {
1798                         DEBUG(0, ("Could not get share mode lock\n"));
1799                         return NT_STATUS_SHARING_VIOLATION;
1800                 }
1801
1802                 /* First pass - send break only on batch oplocks. */
1803                 if ((req != NULL)
1804                     && delay_for_oplocks(lck, fsp, req->mid, 1,
1805                                          oplock_request)) {
1806                         schedule_defer_open(lck, request_time, req);
1807                         TALLOC_FREE(lck);
1808                         return NT_STATUS_SHARING_VIOLATION;
1809                 }
1810
1811                 /* Use the client requested access mask here, not the one we
1812                  * open with. */
1813                 status = open_mode_check(conn, lck, access_mask, share_access,
1814                                          create_options, &file_existed);
1815
1816                 if (NT_STATUS_IS_OK(status)) {
1817                         /* We might be going to allow this open. Check oplock
1818                          * status again. */
1819                         /* Second pass - send break for both batch or
1820                          * exclusive oplocks. */
1821                         if ((req != NULL)
1822                              && delay_for_oplocks(lck, fsp, req->mid, 2,
1823                                                   oplock_request)) {
1824                                 schedule_defer_open(lck, request_time, req);
1825                                 TALLOC_FREE(lck);
1826                                 return NT_STATUS_SHARING_VIOLATION;
1827                         }
1828                 }
1829
1830                 if (NT_STATUS_EQUAL(status, NT_STATUS_DELETE_PENDING)) {
1831                         /* DELETE_PENDING is not deferred for a second */
1832                         TALLOC_FREE(lck);
1833                         return status;
1834                 }
1835
1836                 if (!NT_STATUS_IS_OK(status)) {
1837                         uint32 can_access_mask;
1838                         bool can_access = True;
1839
1840                         SMB_ASSERT(NT_STATUS_EQUAL(status, NT_STATUS_SHARING_VIOLATION));
1841
1842                         /* Check if this can be done with the deny_dos and fcb
1843                          * calls. */
1844                         if (create_options &
1845                             (NTCREATEX_OPTIONS_PRIVATE_DENY_DOS|
1846                              NTCREATEX_OPTIONS_PRIVATE_DENY_FCB)) {
1847                                 if (req == NULL) {
1848                                         DEBUG(0, ("DOS open without an SMB "
1849                                                   "request!\n"));
1850                                         TALLOC_FREE(lck);
1851                                         return NT_STATUS_INTERNAL_ERROR;
1852                                 }
1853
1854                                 /* Use the client requested access mask here,
1855                                  * not the one we open with. */
1856                                 status = fcb_or_dos_open(req,
1857                                                         conn,
1858                                                         fsp,
1859                                                         smb_fname,
1860                                                         id,
1861                                                         req->smbpid,
1862                                                         req->vuid,
1863                                                         access_mask,
1864                                                         share_access,
1865                                                         create_options);
1866
1867                                 if (NT_STATUS_IS_OK(status)) {
1868                                         TALLOC_FREE(lck);
1869                                         if (pinfo) {
1870                                                 *pinfo = FILE_WAS_OPENED;
1871                                         }
1872                                         return NT_STATUS_OK;
1873                                 }
1874                         }
1875
1876                         /*
1877                          * This next line is a subtlety we need for
1878                          * MS-Access. If a file open will fail due to share
1879                          * permissions and also for security (access) reasons,
1880                          * we need to return the access failed error, not the
1881                          * share error. We can't open the file due to kernel
1882                          * oplock deadlock (it's possible we failed above on
1883                          * the open_mode_check()) so use a userspace check.
1884                          */
1885
1886                         if (flags & O_RDWR) {
1887                                 can_access_mask = FILE_READ_DATA|FILE_WRITE_DATA;
1888                         } else if (flags & O_WRONLY) {
1889                                 can_access_mask = FILE_WRITE_DATA;
1890                         } else {
1891                                 can_access_mask = FILE_READ_DATA;
1892                         }
1893
1894                         if (((can_access_mask & FILE_WRITE_DATA) &&
1895                                 !CAN_WRITE(conn)) ||
1896                             !can_access_file_data(conn, smb_fname,
1897                                                   can_access_mask)) {
1898                                 can_access = False;
1899                         }
1900
1901                         /*
1902                          * If we're returning a share violation, ensure we
1903                          * cope with the braindead 1 second delay.
1904                          */
1905
1906                         if (!(oplock_request & INTERNAL_OPEN_ONLY) &&
1907                             lp_defer_sharing_violations()) {
1908                                 struct timeval timeout;
1909                                 struct deferred_open_record state;
1910                                 int timeout_usecs;
1911
1912                                 /* this is a hack to speed up torture tests
1913                                    in 'make test' */
1914                                 timeout_usecs = lp_parm_int(SNUM(conn),
1915                                                             "smbd","sharedelay",
1916                                                             SHARING_VIOLATION_USEC_WAIT);
1917
1918                                 /* This is a relative time, added to the absolute
1919                                    request_time value to get the absolute timeout time.
1920                                    Note that if this is the second or greater time we enter
1921                                    this codepath for this particular request mid then
1922                                    request_time is left as the absolute time of the *first*
1923                                    time this request mid was processed. This is what allows
1924                                    the request to eventually time out. */
1925
1926                                 timeout = timeval_set(0, timeout_usecs);
1927
1928                                 /* Nothing actually uses state.delayed_for_oplocks
1929                                    but it's handy to differentiate in debug messages
1930                                    between a 30 second delay due to oplock break, and
1931                                    a 1 second delay for share mode conflicts. */
1932
1933                                 state.delayed_for_oplocks = False;
1934                                 state.id = id;
1935
1936                                 if ((req != NULL)
1937                                     && !request_timed_out(request_time,
1938                                                           timeout)) {
1939                                         defer_open(lck, request_time, timeout,
1940                                                    req, &state);
1941                                 }
1942                         }
1943
1944                         TALLOC_FREE(lck);
1945                         if (can_access) {
1946                                 /*
1947                                  * We have detected a sharing violation here
1948                                  * so return the correct error code
1949                                  */
1950                                 status = NT_STATUS_SHARING_VIOLATION;
1951                         } else {
1952                                 status = NT_STATUS_ACCESS_DENIED;
1953                         }
1954                         return status;
1955                 }
1956
1957                 /*
1958                  * We exit this block with the share entry *locked*.....
1959                  */
1960         }
1961
1962         SMB_ASSERT(!file_existed || (lck != NULL));
1963
1964         /*
1965          * Ensure we pay attention to default ACLs on directories if required.
1966          */
1967
1968         if ((flags2 & O_CREAT) && lp_inherit_acls(SNUM(conn)) &&
1969             (def_acl = directory_has_default_acl(conn, parent_dir))) {
1970                 unx_mode = (0777 & lp_create_mask(SNUM(conn)));
1971         }
1972
1973         DEBUG(4,("calling open_file with flags=0x%X flags2=0x%X mode=0%o, "
1974                 "access_mask = 0x%x, open_access_mask = 0x%x\n",
1975                  (unsigned int)flags, (unsigned int)flags2,
1976                  (unsigned int)unx_mode, (unsigned int)access_mask,
1977                  (unsigned int)open_access_mask));
1978
1979         /*
1980          * open_file strips any O_TRUNC flags itself.
1981          */
1982
1983         fsp_open = open_file(fsp, conn, req, parent_dir,
1984                              flags|flags2, unx_mode, access_mask,
1985                              open_access_mask);
1986
1987         if (!NT_STATUS_IS_OK(fsp_open)) {
1988                 if (lck != NULL) {
1989                         TALLOC_FREE(lck);
1990                 }
1991                 return fsp_open;
1992         }
1993
1994         if (!file_existed) {
1995                 struct timespec old_write_time = smb_fname->st.st_ex_mtime;
1996                 /*
1997                  * Deal with the race condition where two smbd's detect the
1998                  * file doesn't exist and do the create at the same time. One
1999                  * of them will win and set a share mode, the other (ie. this
2000                  * one) should check if the requested share mode for this
2001                  * create is allowed.
2002                  */
2003
2004                 /*
2005                  * Now the file exists and fsp is successfully opened,
2006                  * fsp->dev and fsp->inode are valid and should replace the
2007                  * dev=0,inode=0 from a non existent file. Spotted by
2008                  * Nadav Danieli <nadavd@exanet.com>. JRA.
2009                  */
2010
2011                 id = fsp->file_id;
2012
2013                 lck = get_share_mode_lock(talloc_tos(), id,
2014                                           conn->connectpath,
2015                                           smb_fname, &old_write_time);
2016
2017                 if (lck == NULL) {
2018                         DEBUG(0, ("open_file_ntcreate: Could not get share "
2019                                   "mode lock for %s\n",
2020                                   smb_fname_str_dbg(smb_fname)));
2021                         fd_close(fsp);
2022                         return NT_STATUS_SHARING_VIOLATION;
2023                 }
2024
2025                 /* First pass - send break only on batch oplocks. */
2026                 if ((req != NULL)
2027                     && delay_for_oplocks(lck, fsp, req->mid, 1,
2028                                          oplock_request)) {
2029                         schedule_defer_open(lck, request_time, req);
2030                         TALLOC_FREE(lck);
2031                         fd_close(fsp);
2032                         return NT_STATUS_SHARING_VIOLATION;
2033                 }
2034
2035                 status = open_mode_check(conn, lck, access_mask, share_access,
2036                                          create_options, &file_existed);
2037
2038                 if (NT_STATUS_IS_OK(status)) {
2039                         /* We might be going to allow this open. Check oplock
2040                          * status again. */
2041                         /* Second pass - send break for both batch or
2042                          * exclusive oplocks. */
2043                         if ((req != NULL)
2044                             && delay_for_oplocks(lck, fsp, req->mid, 2,
2045                                                  oplock_request)) {
2046                                 schedule_defer_open(lck, request_time, req);
2047                                 TALLOC_FREE(lck);
2048                                 fd_close(fsp);
2049                                 return NT_STATUS_SHARING_VIOLATION;
2050                         }
2051                 }
2052
2053                 if (!NT_STATUS_IS_OK(status)) {
2054                         struct deferred_open_record state;
2055
2056                         fd_close(fsp);
2057
2058                         state.delayed_for_oplocks = False;
2059                         state.id = id;
2060
2061                         /* Do it all over again immediately. In the second
2062                          * round we will find that the file existed and handle
2063                          * the DELETE_PENDING and FCB cases correctly. No need
2064                          * to duplicate the code here. Essentially this is a
2065                          * "goto top of this function", but don't tell
2066                          * anybody... */
2067
2068                         if (req != NULL) {
2069                                 defer_open(lck, request_time, timeval_zero(),
2070                                            req, &state);
2071                         }
2072                         TALLOC_FREE(lck);
2073                         return status;
2074                 }
2075
2076                 /*
2077                  * We exit this block with the share entry *locked*.....
2078                  */
2079
2080         }
2081
2082         SMB_ASSERT(lck != NULL);
2083
2084         /* Delete streams if create_disposition requires it */
2085         if (file_existed && clear_ads &&
2086             !is_ntfs_stream_smb_fname(smb_fname)) {
2087                 status = delete_all_streams(conn, smb_fname->base_name);
2088                 if (!NT_STATUS_IS_OK(status)) {
2089                         TALLOC_FREE(lck);
2090                         fd_close(fsp);
2091                         return status;
2092                 }
2093         }
2094
2095         /* note that we ignore failure for the following. It is
2096            basically a hack for NFS, and NFS will never set one of
2097            these only read them. Nobody but Samba can ever set a deny
2098            mode and we have already checked our more authoritative
2099            locking database for permission to set this deny mode. If
2100            the kernel refuses the operations then the kernel is wrong.
2101            note that GPFS supports it as well - jmcd */
2102
2103         if (fsp->fh->fd != -1) {
2104                 int ret_flock;
2105                 ret_flock = SMB_VFS_KERNEL_FLOCK(fsp, share_access, access_mask);
2106                 if(ret_flock == -1 ){
2107
2108                         TALLOC_FREE(lck);
2109                         fd_close(fsp);
2110
2111                         return NT_STATUS_SHARING_VIOLATION;
2112                 }
2113         }
2114
2115         /*
2116          * At this point onwards, we can guarentee that the share entry
2117          * is locked, whether we created the file or not, and that the
2118          * deny mode is compatible with all current opens.
2119          */
2120
2121         /*
2122          * If requested, truncate the file.
2123          */
2124
2125         if (flags2&O_TRUNC) {
2126                 /*
2127                  * We are modifing the file after open - update the stat
2128                  * struct..
2129                  */
2130                 if ((SMB_VFS_FTRUNCATE(fsp, 0) == -1) ||
2131                     (SMB_VFS_FSTAT(fsp, &smb_fname->st)==-1)) {
2132                         status = map_nt_error_from_unix(errno);
2133                         TALLOC_FREE(lck);
2134                         fd_close(fsp);
2135                         return status;
2136                 }
2137         }
2138
2139         /* Record the options we were opened with. */
2140         fsp->share_access = share_access;
2141         fsp->fh->private_options = create_options;
2142         /*
2143          * According to Samba4, SEC_FILE_READ_ATTRIBUTE is always granted,
2144          */
2145         fsp->access_mask = access_mask | FILE_READ_ATTRIBUTES;
2146
2147         if (file_existed) {
2148                 /* stat opens on existing files don't get oplocks. */
2149                 if (is_stat_open(open_access_mask)) {
2150                         fsp->oplock_type = NO_OPLOCK;
2151                 }
2152
2153                 if (!(flags2 & O_TRUNC)) {
2154                         info = FILE_WAS_OPENED;
2155                 } else {
2156                         info = FILE_WAS_OVERWRITTEN;
2157                 }
2158         } else {
2159                 info = FILE_WAS_CREATED;
2160         }
2161
2162         if (pinfo) {
2163                 *pinfo = info;
2164         }
2165
2166         /*
2167          * Setup the oplock info in both the shared memory and
2168          * file structs.
2169          */
2170
2171         if (!set_file_oplock(fsp, fsp->oplock_type)) {
2172                 /* Could not get the kernel oplock */
2173                 fsp->oplock_type = NO_OPLOCK;
2174         }
2175
2176         if (info == FILE_WAS_OVERWRITTEN || info == FILE_WAS_CREATED || info == FILE_WAS_SUPERSEDED) {
2177                 new_file_created = True;
2178         }
2179
2180         set_share_mode(lck, fsp, conn->server_info->utok.uid, 0,
2181                        fsp->oplock_type);
2182
2183         /* Handle strange delete on close create semantics. */
2184         if (create_options & FILE_DELETE_ON_CLOSE) {
2185
2186                 status = can_set_delete_on_close(fsp, new_dos_attributes);
2187
2188                 if (!NT_STATUS_IS_OK(status)) {
2189                         /* Remember to delete the mode we just added. */
2190                         del_share_mode(lck, fsp);
2191                         TALLOC_FREE(lck);
2192                         fd_close(fsp);
2193                         return status;
2194                 }
2195                 /* Note that here we set the *inital* delete on close flag,
2196                    not the regular one. The magic gets handled in close. */
2197                 fsp->initial_delete_on_close = True;
2198         }
2199
2200         if (new_file_created) {
2201                 /* Files should be initially set as archive */
2202                 if (lp_map_archive(SNUM(conn)) ||
2203                     lp_store_dos_attributes(SNUM(conn))) {
2204                         if (!posix_open) {
2205                                 if (file_set_dosmode(conn, smb_fname,
2206                                             new_dos_attributes | aARCH,
2207                                             parent_dir, true) == 0) {
2208                                         unx_mode = smb_fname->st.st_ex_mode;
2209                                 }
2210                         }
2211                 }
2212         }
2213
2214         /*
2215          * Take care of inherited ACLs on created files - if default ACL not
2216          * selected.
2217          */
2218
2219         if (!posix_open && !file_existed && !def_acl) {
2220
2221                 int saved_errno = errno; /* We might get ENOSYS in the next
2222                                           * call.. */
2223
2224                 if (SMB_VFS_FCHMOD_ACL(fsp, unx_mode) == -1 &&
2225                     errno == ENOSYS) {
2226                         errno = saved_errno; /* Ignore ENOSYS */
2227                 }
2228
2229         } else if (new_unx_mode) {
2230
2231                 int ret = -1;
2232
2233                 /* Attributes need changing. File already existed. */
2234
2235                 {
2236                         int saved_errno = errno; /* We might get ENOSYS in the
2237                                                   * next call.. */
2238                         ret = SMB_VFS_FCHMOD_ACL(fsp, new_unx_mode);
2239
2240                         if (ret == -1 && errno == ENOSYS) {
2241                                 errno = saved_errno; /* Ignore ENOSYS */
2242                         } else {
2243                                 DEBUG(5, ("open_file_ntcreate: reset "
2244                                           "attributes of file %s to 0%o\n",
2245                                           smb_fname_str_dbg(smb_fname),
2246                                           (unsigned int)new_unx_mode));
2247                                 ret = 0; /* Don't do the fchmod below. */
2248                         }
2249                 }
2250
2251                 if ((ret == -1) &&
2252                     (SMB_VFS_FCHMOD(fsp, new_unx_mode) == -1))
2253                         DEBUG(5, ("open_file_ntcreate: failed to reset "
2254                                   "attributes of file %s to 0%o\n",
2255                                   smb_fname_str_dbg(smb_fname),
2256                                   (unsigned int)new_unx_mode));
2257         }
2258
2259         /* If this is a successful open, we must remove any deferred open
2260          * records. */
2261         if (req != NULL) {
2262                 del_deferred_open_entry(lck, req->mid);
2263         }
2264         TALLOC_FREE(lck);
2265
2266         return NT_STATUS_OK;
2267 }
2268
2269
2270 /****************************************************************************
2271  Open a file for for write to ensure that we can fchmod it.
2272 ****************************************************************************/
2273
2274 NTSTATUS open_file_fchmod(connection_struct *conn,
2275                           struct smb_filename *smb_fname,
2276                           files_struct **result)
2277 {
2278         if (!VALID_STAT(smb_fname->st)) {
2279                 return NT_STATUS_INVALID_PARAMETER;
2280         }
2281
2282         return SMB_VFS_CREATE_FILE(
2283                 conn,                                   /* conn */
2284                 NULL,                                   /* req */
2285                 0,                                      /* root_dir_fid */
2286                 smb_fname,                              /* fname */
2287                 FILE_WRITE_DATA,                        /* access_mask */
2288                 (FILE_SHARE_READ | FILE_SHARE_WRITE |   /* share_access */
2289                     FILE_SHARE_DELETE),
2290                 FILE_OPEN,                              /* create_disposition*/
2291                 0,                                      /* create_options */
2292                 0,                                      /* file_attributes */
2293                 INTERNAL_OPEN_ONLY,                     /* oplock_request */
2294                 0,                                      /* allocation_size */
2295                 NULL,                                   /* sd */
2296                 NULL,                                   /* ea_list */
2297                 result,                                 /* result */
2298                 NULL);                                  /* pinfo */
2299 }
2300
2301 static NTSTATUS mkdir_internal(connection_struct *conn,
2302                                struct smb_filename *smb_dname,
2303                                uint32 file_attributes)
2304 {
2305         mode_t mode;
2306         char *parent_dir;
2307         NTSTATUS status;
2308         bool posix_open = false;
2309
2310         if(!CAN_WRITE(conn)) {
2311                 DEBUG(5,("mkdir_internal: failing create on read-only share "
2312                          "%s\n", lp_servicename(SNUM(conn))));
2313                 return NT_STATUS_ACCESS_DENIED;
2314         }
2315
2316         status = check_name(conn, smb_dname->base_name);
2317         if (!NT_STATUS_IS_OK(status)) {
2318                 return status;
2319         }
2320
2321         if (!parent_dirname(talloc_tos(), smb_dname->base_name, &parent_dir,
2322                             NULL)) {
2323                 return NT_STATUS_NO_MEMORY;
2324         }
2325
2326         if (file_attributes & FILE_FLAG_POSIX_SEMANTICS) {
2327                 posix_open = true;
2328                 mode = (mode_t)(file_attributes & ~FILE_FLAG_POSIX_SEMANTICS);
2329         } else {
2330                 mode = unix_mode(conn, aDIR, smb_dname, parent_dir);
2331         }
2332
2333         if (SMB_VFS_MKDIR(conn, smb_dname->base_name, mode) != 0) {
2334                 return map_nt_error_from_unix(errno);
2335         }
2336
2337         /* Ensure we're checking for a symlink here.... */
2338         /* We don't want to get caught by a symlink racer. */
2339
2340         if (SMB_VFS_LSTAT(conn, smb_dname) == -1) {
2341                 DEBUG(2, ("Could not stat directory '%s' just created: %s\n",
2342                           smb_fname_str_dbg(smb_dname), strerror(errno)));
2343                 return map_nt_error_from_unix(errno);
2344         }
2345
2346         if (!S_ISDIR(smb_dname->st.st_ex_mode)) {
2347                 DEBUG(0, ("Directory just '%s' created is not a directory\n",
2348                           smb_fname_str_dbg(smb_dname)));
2349                 return NT_STATUS_ACCESS_DENIED;
2350         }
2351
2352         if (lp_store_dos_attributes(SNUM(conn))) {
2353                 if (!posix_open) {
2354                         file_set_dosmode(conn, smb_dname,
2355                                          file_attributes | aDIR,
2356                                          parent_dir, true);
2357                 }
2358         }
2359
2360         if (lp_inherit_perms(SNUM(conn))) {
2361                 inherit_access_posix_acl(conn, parent_dir,
2362                                          smb_dname->base_name, mode);
2363         }
2364
2365         if (!posix_open) {
2366                 /*
2367                  * Check if high bits should have been set,
2368                  * then (if bits are missing): add them.
2369                  * Consider bits automagically set by UNIX, i.e. SGID bit from parent
2370                  * dir.
2371                  */
2372                 if ((mode & ~(S_IRWXU|S_IRWXG|S_IRWXO)) &&
2373                     (mode & ~smb_dname->st.st_ex_mode)) {
2374                         SMB_VFS_CHMOD(conn, smb_dname->base_name,
2375                                       (smb_dname->st.st_ex_mode |
2376                                           (mode & ~smb_dname->st.st_ex_mode)));
2377                 }
2378         }
2379
2380         /* Change the owner if required. */
2381         if (lp_inherit_owner(SNUM(conn))) {
2382                 change_dir_owner_to_parent(conn, parent_dir,
2383                                            smb_dname->base_name,
2384                                            &smb_dname->st);
2385         }
2386
2387         notify_fname(conn, NOTIFY_ACTION_ADDED, FILE_NOTIFY_CHANGE_DIR_NAME,
2388                      smb_dname->base_name);
2389
2390         return NT_STATUS_OK;
2391 }
2392
2393 /****************************************************************************
2394  Open a directory from an NT SMB call.
2395 ****************************************************************************/
2396
2397 static NTSTATUS open_directory(connection_struct *conn,
2398                                struct smb_request *req,
2399                                struct smb_filename *smb_dname,
2400                                uint32 access_mask,
2401                                uint32 share_access,
2402                                uint32 create_disposition,
2403                                uint32 create_options,
2404                                uint32 file_attributes,
2405                                int *pinfo,
2406                                files_struct **result)
2407 {
2408         files_struct *fsp = NULL;
2409         bool dir_existed = VALID_STAT(smb_dname->st) ? True : False;
2410         struct share_mode_lock *lck = NULL;
2411         NTSTATUS status;
2412         struct timespec mtimespec;
2413         int info = 0;
2414
2415         SMB_ASSERT(!is_ntfs_stream_smb_fname(smb_dname));
2416
2417         /* Ensure we have a directory attribute. */
2418         file_attributes |= FILE_ATTRIBUTE_DIRECTORY;
2419
2420         DEBUG(5,("open_directory: opening directory %s, access_mask = 0x%x, "
2421                  "share_access = 0x%x create_options = 0x%x, "
2422                  "create_disposition = 0x%x, file_attributes = 0x%x\n",
2423                  smb_fname_str_dbg(smb_dname),
2424                  (unsigned int)access_mask,
2425                  (unsigned int)share_access,
2426                  (unsigned int)create_options,
2427                  (unsigned int)create_disposition,
2428                  (unsigned int)file_attributes));
2429
2430         if (!(file_attributes & FILE_FLAG_POSIX_SEMANTICS) &&
2431                         (conn->fs_capabilities & FILE_NAMED_STREAMS) &&
2432                         is_ntfs_stream_smb_fname(smb_dname)) {
2433                 DEBUG(2, ("open_directory: %s is a stream name!\n",
2434                           smb_fname_str_dbg(smb_dname)));
2435                 return NT_STATUS_NOT_A_DIRECTORY;
2436         }
2437
2438         status = calculate_access_mask(conn, smb_dname, dir_existed,
2439                                        access_mask, &access_mask);
2440         if (!NT_STATUS_IS_OK(status)) {
2441                 DEBUG(10, ("open_directory: calculate_access_mask "
2442                         "on file %s returned %s\n",
2443                         smb_fname_str_dbg(smb_dname),
2444                         nt_errstr(status)));
2445                 return status;
2446         }
2447
2448         if ((access_mask & SEC_FLAG_SYSTEM_SECURITY) &&
2449                         !user_has_privileges(current_user.nt_user_token, &se_security)) {
2450                 DEBUG(10, ("open_directory: open on %s "
2451                         "failed - SEC_FLAG_SYSTEM_SECURITY denied.\n",
2452                         smb_fname_str_dbg(smb_dname)));
2453                 return NT_STATUS_PRIVILEGE_NOT_HELD;
2454         }
2455
2456         switch( create_disposition ) {
2457                 case FILE_OPEN:
2458
2459                         info = FILE_WAS_OPENED;
2460
2461                         /*
2462                          * We want to follow symlinks here.
2463                          */
2464
2465                         if (SMB_VFS_STAT(conn, smb_dname) != 0) {
2466                                 return map_nt_error_from_unix(errno);
2467                         }
2468
2469                         break;
2470
2471                 case FILE_CREATE:
2472
2473                         /* If directory exists error. If directory doesn't
2474                          * exist create. */
2475
2476                         status = mkdir_internal(conn, smb_dname,
2477                                                 file_attributes);
2478
2479                         if (!NT_STATUS_IS_OK(status)) {
2480                                 DEBUG(2, ("open_directory: unable to create "
2481                                           "%s. Error was %s\n",
2482                                           smb_fname_str_dbg(smb_dname),
2483                                           nt_errstr(status)));
2484                                 return status;
2485                         }
2486
2487                         info = FILE_WAS_CREATED;
2488                         break;
2489
2490                 case FILE_OPEN_IF:
2491                         /*
2492                          * If directory exists open. If directory doesn't
2493                          * exist create.
2494                          */
2495
2496                         status = mkdir_internal(conn, smb_dname,
2497                                                 file_attributes);
2498
2499                         if (NT_STATUS_IS_OK(status)) {
2500                                 info = FILE_WAS_CREATED;
2501                         }
2502
2503                         if (NT_STATUS_EQUAL(status,
2504                                             NT_STATUS_OBJECT_NAME_COLLISION)) {
2505                                 info = FILE_WAS_OPENED;
2506                                 status = NT_STATUS_OK;
2507                         }
2508
2509                         break;
2510
2511                 case FILE_SUPERSEDE:
2512                 case FILE_OVERWRITE:
2513                 case FILE_OVERWRITE_IF:
2514                 default:
2515                         DEBUG(5,("open_directory: invalid create_disposition "
2516                                  "0x%x for directory %s\n",
2517                                  (unsigned int)create_disposition,
2518                                  smb_fname_str_dbg(smb_dname)));
2519                         return NT_STATUS_INVALID_PARAMETER;
2520         }
2521
2522         if(!S_ISDIR(smb_dname->st.st_ex_mode)) {
2523                 DEBUG(5,("open_directory: %s is not a directory !\n",
2524                          smb_fname_str_dbg(smb_dname)));
2525                 return NT_STATUS_NOT_A_DIRECTORY;
2526         }
2527
2528         if (info == FILE_WAS_OPENED) {
2529                 uint32_t access_granted = 0;
2530                 status = smbd_check_open_rights(conn, smb_dname, access_mask,
2531                                                 &access_granted);
2532
2533                 /* Were we trying to do a directory open
2534                  * for delete and didn't get DELETE
2535                  * access (only) ? Check if the
2536                  * directory allows DELETE_CHILD.
2537                  * See here:
2538                  * http://blogs.msdn.com/oldnewthing/archive/2004/06/04/148426.aspx
2539                  * for details. */
2540
2541                 if ((NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED) &&
2542                         (access_mask & DELETE_ACCESS) &&
2543                         (access_granted == DELETE_ACCESS) &&
2544                         can_delete_file_in_directory(conn, smb_dname))) {
2545                         DEBUG(10,("open_directory: overrode ACCESS_DENIED "
2546                                 "on directory %s\n",
2547                                 smb_fname_str_dbg(smb_dname)));
2548                         status = NT_STATUS_OK;
2549                 }
2550
2551                 if (!NT_STATUS_IS_OK(status)) {
2552                         DEBUG(10, ("open_directory: smbd_check_open_rights on "
2553                                 "file %s failed with %s\n",
2554                                 smb_fname_str_dbg(smb_dname),
2555                                 nt_errstr(status)));
2556                         return status;
2557                 }
2558         }
2559
2560         status = file_new(req, conn, &fsp);
2561         if(!NT_STATUS_IS_OK(status)) {
2562                 return status;
2563         }
2564
2565         /*
2566          * Setup the files_struct for it.
2567          */
2568
2569         fsp->mode = smb_dname->st.st_ex_mode;
2570         fsp->file_id = vfs_file_id_from_sbuf(conn, &smb_dname->st);
2571         fsp->vuid = req ? req->vuid : UID_FIELD_INVALID;
2572         fsp->file_pid = req ? req->smbpid : 0;
2573         fsp->can_lock = False;
2574         fsp->can_read = False;
2575         fsp->can_write = False;
2576
2577         fsp->share_access = share_access;
2578         fsp->fh->private_options = create_options;
2579         /*
2580          * According to Samba4, SEC_FILE_READ_ATTRIBUTE is always granted,
2581          */
2582         fsp->access_mask = access_mask | FILE_READ_ATTRIBUTES;
2583         fsp->print_file = False;
2584         fsp->modified = False;
2585         fsp->oplock_type = NO_OPLOCK;
2586         fsp->sent_oplock_break = NO_BREAK_SENT;
2587         fsp->is_directory = True;
2588         fsp->posix_open = (file_attributes & FILE_FLAG_POSIX_SEMANTICS) ? True : False;
2589         status = fsp_set_smb_fname(fsp, smb_dname);
2590         if (!NT_STATUS_IS_OK(status)) {
2591                 return status;
2592         }
2593
2594         mtimespec = smb_dname->st.st_ex_mtime;
2595
2596         lck = get_share_mode_lock(talloc_tos(), fsp->file_id,
2597                                   conn->connectpath, smb_dname, &mtimespec);
2598
2599         if (lck == NULL) {
2600                 DEBUG(0, ("open_directory: Could not get share mode lock for "
2601                           "%s\n", smb_fname_str_dbg(smb_dname)));
2602                 file_free(req, fsp);
2603                 return NT_STATUS_SHARING_VIOLATION;
2604         }
2605
2606         status = open_mode_check(conn, lck, access_mask, share_access,
2607                                  create_options, &dir_existed);
2608
2609         if (!NT_STATUS_IS_OK(status)) {
2610                 TALLOC_FREE(lck);
2611                 file_free(req, fsp);
2612                 return status;
2613         }
2614
2615         set_share_mode(lck, fsp, conn->server_info->utok.uid, 0, NO_OPLOCK);
2616
2617         /* For directories the delete on close bit at open time seems
2618            always to be honored on close... See test 19 in Samba4 BASE-DELETE. */
2619         if (create_options & FILE_DELETE_ON_CLOSE) {
2620                 status = can_set_delete_on_close(fsp, 0);
2621                 if (!NT_STATUS_IS_OK(status) && !NT_STATUS_EQUAL(status, NT_STATUS_DIRECTORY_NOT_EMPTY)) {
2622                         TALLOC_FREE(lck);
2623                         file_free(req, fsp);
2624                         return status;
2625                 }
2626
2627                 if (NT_STATUS_IS_OK(status)) {
2628                         /* Note that here we set the *inital* delete on close flag,
2629                            not the regular one. The magic gets handled in close. */
2630                         fsp->initial_delete_on_close = True;
2631                 }
2632         }
2633
2634         TALLOC_FREE(lck);
2635
2636         if (pinfo) {
2637                 *pinfo = info;
2638         }
2639
2640         *result = fsp;
2641         return NT_STATUS_OK;
2642 }
2643
2644 NTSTATUS create_directory(connection_struct *conn, struct smb_request *req,
2645                           struct smb_filename *smb_dname)
2646 {
2647         NTSTATUS status;
2648         files_struct *fsp;
2649
2650         status = SMB_VFS_CREATE_FILE(
2651                 conn,                                   /* conn */
2652                 req,                                    /* req */
2653                 0,                                      /* root_dir_fid */
2654                 smb_dname,                              /* fname */
2655                 FILE_READ_ATTRIBUTES,                   /* access_mask */
2656                 FILE_SHARE_NONE,                        /* share_access */
2657                 FILE_CREATE,                            /* create_disposition*/
2658                 FILE_DIRECTORY_FILE,                    /* create_options */
2659                 FILE_ATTRIBUTE_DIRECTORY,               /* file_attributes */
2660                 0,                                      /* oplock_request */
2661                 0,                                      /* allocation_size */
2662                 NULL,                                   /* sd */
2663                 NULL,                                   /* ea_list */
2664                 &fsp,                                   /* result */
2665                 NULL);                                  /* pinfo */
2666
2667         if (NT_STATUS_IS_OK(status)) {
2668                 close_file(req, fsp, NORMAL_CLOSE);
2669         }
2670
2671         return status;
2672 }
2673
2674 /****************************************************************************
2675  Receive notification that one of our open files has been renamed by another
2676  smbd process.
2677 ****************************************************************************/
2678
2679 void msg_file_was_renamed(struct messaging_context *msg,
2680                           void *private_data,
2681                           uint32_t msg_type,
2682                           struct server_id server_id,
2683                           DATA_BLOB *data)
2684 {
2685         files_struct *fsp;
2686         char *frm = (char *)data->data;
2687         struct file_id id;
2688         const char *sharepath;
2689         const char *base_name;
2690         const char *stream_name;
2691         struct smb_filename *smb_fname = NULL;
2692         size_t sp_len, bn_len;
2693         NTSTATUS status;
2694
2695         if (data->data == NULL
2696             || data->length < MSG_FILE_RENAMED_MIN_SIZE + 2) {
2697                 DEBUG(0, ("msg_file_was_renamed: Got invalid msg len %d\n",
2698                           (int)data->length));
2699                 return;
2700         }
2701
2702         /* Unpack the message. */
2703         pull_file_id_24(frm, &id);
2704         sharepath = &frm[24];
2705         sp_len = strlen(sharepath);
2706         base_name = sharepath + sp_len + 1;
2707         bn_len = strlen(base_name);
2708         stream_name = sharepath + sp_len + 1 + bn_len + 1;
2709
2710         /* stream_name must always be NULL if there is no stream. */
2711         if (stream_name[0] == '\0') {
2712                 stream_name = NULL;
2713         }
2714
2715         status = create_synthetic_smb_fname(talloc_tos(), base_name,
2716                                             stream_name, NULL, &smb_fname);
2717         if (!NT_STATUS_IS_OK(status)) {
2718                 return;
2719         }
2720
2721         DEBUG(10,("msg_file_was_renamed: Got rename message for sharepath %s, new name %s, "
2722                 "file_id %s\n",
2723                 sharepath, smb_fname_str_dbg(smb_fname),
2724                 file_id_string_tos(&id)));
2725
2726         for(fsp = file_find_di_first(id); fsp; fsp = file_find_di_next(fsp)) {
2727                 if (memcmp(fsp->conn->connectpath, sharepath, sp_len) == 0) {
2728
2729                         DEBUG(10,("msg_file_was_renamed: renaming file fnum %d from %s -> %s\n",
2730                                 fsp->fnum, fsp_str_dbg(fsp),
2731                                 smb_fname_str_dbg(smb_fname)));
2732                         status = fsp_set_smb_fname(fsp, smb_fname);
2733                         if (!NT_STATUS_IS_OK(status)) {
2734                                 goto out;
2735                         }
2736                 } else {
2737                         /* TODO. JRA. */
2738                         /* Now we have the complete path we can work out if this is
2739                            actually within this share and adjust newname accordingly. */
2740                         DEBUG(10,("msg_file_was_renamed: share mismatch (sharepath %s "
2741                                 "not sharepath %s) "
2742                                 "fnum %d from %s -> %s\n",
2743                                 fsp->conn->connectpath,
2744                                 sharepath,
2745                                 fsp->fnum,
2746                                 fsp_str_dbg(fsp),
2747                                 smb_fname_str_dbg(smb_fname)));
2748                 }
2749         }
2750  out:
2751         TALLOC_FREE(smb_fname);
2752         return;
2753 }
2754
2755 /*
2756  * If a main file is opened for delete, all streams need to be checked for
2757  * !FILE_SHARE_DELETE. Do this by opening with DELETE_ACCESS.
2758  * If that works, delete them all by setting the delete on close and close.
2759  */
2760
2761 NTSTATUS open_streams_for_delete(connection_struct *conn,
2762                                         const char *fname)
2763 {
2764         struct stream_struct *stream_info;
2765         files_struct **streams;
2766         int i;
2767         unsigned int num_streams;
2768         TALLOC_CTX *frame = talloc_stackframe();
2769         NTSTATUS status;
2770
2771         status = SMB_VFS_STREAMINFO(conn, NULL, fname, talloc_tos(),
2772                                     &num_streams, &stream_info);
2773
2774         if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_IMPLEMENTED)
2775             || NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
2776                 DEBUG(10, ("no streams around\n"));
2777                 TALLOC_FREE(frame);
2778                 return NT_STATUS_OK;
2779         }
2780
2781         if (!NT_STATUS_IS_OK(status)) {
2782                 DEBUG(10, ("SMB_VFS_STREAMINFO failed: %s\n",
2783                            nt_errstr(status)));
2784                 goto fail;
2785         }
2786
2787         DEBUG(10, ("open_streams_for_delete found %d streams\n",
2788                    num_streams));
2789
2790         if (num_streams == 0) {
2791                 TALLOC_FREE(frame);
2792                 return NT_STATUS_OK;
2793         }
2794
2795         streams = TALLOC_ARRAY(talloc_tos(), files_struct *, num_streams);
2796         if (streams == NULL) {
2797                 DEBUG(0, ("talloc failed\n"));
2798                 status = NT_STATUS_NO_MEMORY;
2799                 goto fail;
2800         }
2801
2802         for (i=0; i<num_streams; i++) {
2803                 struct smb_filename *smb_fname = NULL;
2804
2805                 if (strequal(stream_info[i].name, "::$DATA")) {
2806                         streams[i] = NULL;
2807                         continue;
2808                 }
2809
2810                 status = create_synthetic_smb_fname(talloc_tos(), fname,
2811                                                     stream_info[i].name,
2812                                                     NULL, &smb_fname);
2813                 if (!NT_STATUS_IS_OK(status)) {
2814                         goto fail;
2815                 }
2816
2817                 if (SMB_VFS_STAT(conn, smb_fname) == -1) {
2818                         DEBUG(10, ("Unable to stat stream: %s\n",
2819                                    smb_fname_str_dbg(smb_fname)));
2820                 }
2821
2822                 status = SMB_VFS_CREATE_FILE(
2823                          conn,                  /* conn */
2824                          NULL,                  /* req */
2825                          0,                     /* root_dir_fid */
2826                          smb_fname,             /* fname */
2827                          DELETE_ACCESS,         /* access_mask */
2828                          (FILE_SHARE_READ |     /* share_access */
2829                              FILE_SHARE_WRITE | FILE_SHARE_DELETE),
2830                          FILE_OPEN,             /* create_disposition*/
2831                          NTCREATEX_OPTIONS_PRIVATE_STREAM_DELETE, /* create_options */
2832                          FILE_ATTRIBUTE_NORMAL, /* file_attributes */
2833                          0,                     /* oplock_request */
2834                          0,                     /* allocation_size */
2835                          NULL,                  /* sd */
2836                          NULL,                  /* ea_list */
2837                          &streams[i],           /* result */
2838                          NULL);                 /* pinfo */
2839
2840                 if (!NT_STATUS_IS_OK(status)) {
2841                         DEBUG(10, ("Could not open stream %s: %s\n",
2842                                    smb_fname_str_dbg(smb_fname),
2843                                    nt_errstr(status)));
2844
2845                         TALLOC_FREE(smb_fname);
2846                         break;
2847                 }
2848                 TALLOC_FREE(smb_fname);
2849         }
2850
2851         /*
2852          * don't touch the variable "status" beyond this point :-)
2853          */
2854
2855         for (i -= 1 ; i >= 0; i--) {
2856                 if (streams[i] == NULL) {
2857                         continue;
2858                 }
2859
2860                 DEBUG(10, ("Closing stream # %d, %s\n", i,
2861                            fsp_str_dbg(streams[i])));
2862                 close_file(NULL, streams[i], NORMAL_CLOSE);
2863         }
2864
2865  fail:
2866         TALLOC_FREE(frame);
2867         return status;
2868 }
2869
2870 /*
2871  * Wrapper around open_file_ntcreate and open_directory
2872  */
2873
2874 static NTSTATUS create_file_unixpath(connection_struct *conn,
2875                                      struct smb_request *req,
2876                                      struct smb_filename *smb_fname,
2877                                      uint32_t access_mask,
2878                                      uint32_t share_access,
2879                                      uint32_t create_disposition,
2880                                      uint32_t create_options,
2881                                      uint32_t file_attributes,
2882                                      uint32_t oplock_request,
2883                                      uint64_t allocation_size,
2884                                      struct security_descriptor *sd,
2885                                      struct ea_list *ea_list,
2886
2887                                      files_struct **result,
2888                                      int *pinfo)
2889 {
2890         int info = FILE_WAS_OPENED;
2891         files_struct *base_fsp = NULL;
2892         files_struct *fsp = NULL;
2893         NTSTATUS status;
2894
2895         DEBUG(10,("create_file_unixpath: access_mask = 0x%x "
2896                   "file_attributes = 0x%x, share_access = 0x%x, "
2897                   "create_disposition = 0x%x create_options = 0x%x "
2898                   "oplock_request = 0x%x ea_list = 0x%p, sd = 0x%p, "
2899                   "fname = %s\n",
2900                   (unsigned int)access_mask,
2901                   (unsigned int)file_attributes,
2902                   (unsigned int)share_access,
2903                   (unsigned int)create_disposition,
2904                   (unsigned int)create_options,
2905                   (unsigned int)oplock_request,
2906                   ea_list, sd, smb_fname_str_dbg(smb_fname)));
2907
2908         if (create_options & FILE_OPEN_BY_FILE_ID) {
2909                 status = NT_STATUS_NOT_SUPPORTED;
2910                 goto fail;
2911         }
2912
2913         if (create_options & NTCREATEX_OPTIONS_INVALID_PARAM_MASK) {
2914                 status = NT_STATUS_INVALID_PARAMETER;
2915                 goto fail;
2916         }
2917
2918         if (req == NULL) {
2919                 oplock_request |= INTERNAL_OPEN_ONLY;
2920         }
2921
2922         if ((conn->fs_capabilities & FILE_NAMED_STREAMS)
2923             && (access_mask & DELETE_ACCESS)
2924             && !is_ntfs_stream_smb_fname(smb_fname)) {
2925                 /*
2926                  * We can't open a file with DELETE access if any of the
2927                  * streams is open without FILE_SHARE_DELETE
2928                  */
2929                 status = open_streams_for_delete(conn, smb_fname->base_name);
2930
2931                 if (!NT_STATUS_IS_OK(status)) {
2932                         goto fail;
2933                 }
2934         }
2935
2936         /* This is the correct thing to do (check every time) but can_delete
2937          * is expensive (it may have to read the parent directory
2938          * permissions). So for now we're not doing it unless we have a strong
2939          * hint the client is really going to delete this file. If the client
2940          * is forcing FILE_CREATE let the filesystem take care of the
2941          * permissions. */
2942
2943         /* Setting FILE_SHARE_DELETE is the hint. */
2944
2945         if (lp_acl_check_permissions(SNUM(conn))
2946             && (create_disposition != FILE_CREATE)
2947             && (share_access & FILE_SHARE_DELETE)
2948             && (access_mask & DELETE_ACCESS)
2949             && (!(can_delete_file_in_directory(conn, smb_fname) ||
2950                  can_access_file_acl(conn, smb_fname, DELETE_ACCESS)))) {
2951                 status = NT_STATUS_ACCESS_DENIED;
2952                 DEBUG(10,("create_file_unixpath: open file %s "
2953                           "for delete ACCESS_DENIED\n",
2954                           smb_fname_str_dbg(smb_fname)));
2955                 goto fail;
2956         }
2957
2958         if ((access_mask & SEC_FLAG_SYSTEM_SECURITY) &&
2959                         !user_has_privileges(current_user.nt_user_token, &se_security)) {
2960                 DEBUG(10, ("create_file_unixpath:: open on %s "
2961                         "failed - SEC_FLAG_SYSTEM_SECURITY denied.\n",
2962                         smb_fname_str_dbg(smb_fname)));
2963                 status = NT_STATUS_PRIVILEGE_NOT_HELD;
2964                 goto fail;
2965         }
2966
2967         if ((conn->fs_capabilities & FILE_NAMED_STREAMS)
2968             && is_ntfs_stream_smb_fname(smb_fname)
2969             && (!(create_options & NTCREATEX_OPTIONS_PRIVATE_STREAM_DELETE))) {
2970                 uint32 base_create_disposition;
2971                 struct smb_filename *smb_fname_base = NULL;
2972
2973                 if (create_options & FILE_DIRECTORY_FILE) {
2974                         status = NT_STATUS_NOT_A_DIRECTORY;
2975                         goto fail;
2976                 }
2977
2978                 switch (create_disposition) {
2979                 case FILE_OPEN:
2980                         base_create_disposition = FILE_OPEN;
2981                         break;
2982                 default:
2983                         base_create_disposition = FILE_OPEN_IF;
2984                         break;
2985                 }
2986
2987                 /* Create an smb_filename with stream_name == NULL. */
2988                 status = create_synthetic_smb_fname(talloc_tos(),
2989                                                     smb_fname->base_name,
2990                                                     NULL, NULL,
2991                                                     &smb_fname_base);
2992                 if (!NT_STATUS_IS_OK(status)) {
2993                         goto fail;
2994                 }
2995
2996                 if (SMB_VFS_STAT(conn, smb_fname_base) == -1) {
2997                         DEBUG(10, ("Unable to stat stream: %s\n",
2998                                    smb_fname_str_dbg(smb_fname_base)));
2999                 }
3000
3001                 /* Open the base file. */
3002                 status = create_file_unixpath(conn, NULL, smb_fname_base, 0,
3003                                               FILE_SHARE_READ
3004                                               | FILE_SHARE_WRITE
3005                                               | FILE_SHARE_DELETE,
3006                                               base_create_disposition,
3007                                               0, 0, 0, 0, NULL, NULL,
3008                                               &base_fsp, NULL);
3009                 TALLOC_FREE(smb_fname_base);
3010
3011                 if (!NT_STATUS_IS_OK(status)) {
3012                         DEBUG(10, ("create_file_unixpath for base %s failed: "
3013                                    "%s\n", smb_fname->base_name,
3014                                    nt_errstr(status)));
3015                         goto fail;
3016                 }
3017                 /* we don't need to low level fd */
3018                 fd_close(base_fsp);
3019         }
3020
3021         /*
3022          * If it's a request for a directory open, deal with it separately.
3023          */
3024
3025         if (create_options & FILE_DIRECTORY_FILE) {
3026
3027                 if (create_options & FILE_NON_DIRECTORY_FILE) {
3028                         status = NT_STATUS_INVALID_PARAMETER;
3029                         goto fail;
3030                 }
3031
3032                 /* Can't open a temp directory. IFS kit test. */
3033                 if (!(file_attributes & FILE_FLAG_POSIX_SEMANTICS) &&
3034                      (file_attributes & FILE_ATTRIBUTE_TEMPORARY)) {
3035                         status = NT_STATUS_INVALID_PARAMETER;
3036                         goto fail;
3037                 }
3038
3039                 /*
3040                  * We will get a create directory here if the Win32
3041                  * app specified a security descriptor in the
3042                  * CreateDirectory() call.
3043                  */
3044
3045                 oplock_request = 0;
3046                 status = open_directory(
3047                         conn, req, smb_fname, access_mask, share_access,
3048                         create_disposition, create_options, file_attributes,
3049                         &info, &fsp);
3050         } else {
3051
3052                 /*
3053                  * Ordinary file case.
3054                  */
3055
3056                 status = file_new(req, conn, &fsp);
3057                 if(!NT_STATUS_IS_OK(status)) {
3058                         goto fail;
3059                 }
3060
3061                 status = fsp_set_smb_fname(fsp, smb_fname);
3062                 if (!NT_STATUS_IS_OK(status)) {
3063                         goto fail;
3064                 }
3065
3066                 /*
3067                  * We're opening the stream element of a base_fsp
3068                  * we already opened. Set up the base_fsp pointer.
3069                  */
3070                 if (base_fsp) {
3071                         fsp->base_fsp = base_fsp;
3072                 }
3073
3074                 status = open_file_ntcreate(conn,
3075                                             req,
3076                                             access_mask,
3077                                             share_access,
3078                                             create_disposition,
3079                                             create_options,
3080                                             file_attributes,
3081                                             oplock_request,
3082                                             &info,
3083                                             fsp);
3084
3085                 if(!NT_STATUS_IS_OK(status)) {
3086                         file_free(req, fsp);
3087                         fsp = NULL;
3088                 }
3089
3090                 if (NT_STATUS_EQUAL(status, NT_STATUS_FILE_IS_A_DIRECTORY)) {
3091
3092                         /* A stream open never opens a directory */
3093
3094                         if (base_fsp) {
3095                                 status = NT_STATUS_FILE_IS_A_DIRECTORY;
3096                                 goto fail;
3097                         }
3098
3099                         /*
3100                          * Fail the open if it was explicitly a non-directory
3101                          * file.
3102                          */
3103
3104                         if (create_options & FILE_NON_DIRECTORY_FILE) {
3105                                 status = NT_STATUS_FILE_IS_A_DIRECTORY;
3106                                 goto fail;
3107                         }
3108
3109                         oplock_request = 0;
3110                         status = open_directory(
3111                                 conn, req, smb_fname, access_mask,
3112                                 share_access, create_disposition,
3113                                 create_options, file_attributes,
3114                                 &info, &fsp);
3115                 }
3116         }
3117
3118         if (!NT_STATUS_IS_OK(status)) {
3119                 goto fail;
3120         }
3121
3122         fsp->base_fsp = base_fsp;
3123
3124         /*
3125          * According to the MS documentation, the only time the security
3126          * descriptor is applied to the opened file is iff we *created* the
3127          * file; an existing file stays the same.
3128          *
3129          * Also, it seems (from observation) that you can open the file with
3130          * any access mask but you can still write the sd. We need to override
3131          * the granted access before we call set_sd
3132          * Patch for bug #2242 from Tom Lackemann <cessnatomny@yahoo.com>.
3133          */
3134
3135         if ((sd != NULL) && (info == FILE_WAS_CREATED)
3136             && lp_nt_acl_support(SNUM(conn))) {
3137
3138                 uint32_t sec_info_sent;
3139                 uint32_t saved_access_mask = fsp->access_mask;
3140
3141                 sec_info_sent = get_sec_info(sd);
3142
3143                 fsp->access_mask = FILE_GENERIC_ALL;
3144
3145                 /* Convert all the generic bits. */
3146                 security_acl_map_generic(sd->dacl, &file_generic_mapping);
3147                 security_acl_map_generic(sd->sacl, &file_generic_mapping);
3148
3149                 if (sec_info_sent & (OWNER_SECURITY_INFORMATION|
3150                                         GROUP_SECURITY_INFORMATION|
3151                                         DACL_SECURITY_INFORMATION|
3152                                         SACL_SECURITY_INFORMATION)) {
3153                         status = SMB_VFS_FSET_NT_ACL(fsp, sec_info_sent, sd);
3154                 }
3155
3156                 fsp->access_mask = saved_access_mask;
3157
3158                 if (!NT_STATUS_IS_OK(status)) {
3159                         goto fail;
3160                 }
3161         }
3162
3163         if ((ea_list != NULL) &&
3164             ((info == FILE_WAS_CREATED) || (info == FILE_WAS_OVERWRITTEN))) {
3165                 status = set_ea(conn, fsp, fsp->fsp_name, ea_list);
3166                 if (!NT_STATUS_IS_OK(status)) {
3167                         goto fail;
3168                 }
3169         }
3170
3171         if (!fsp->is_directory && S_ISDIR(fsp->fsp_name->st.st_ex_mode)) {
3172                 status = NT_STATUS_ACCESS_DENIED;
3173                 goto fail;
3174         }
3175
3176         /* Save the requested allocation size. */
3177         if ((info == FILE_WAS_CREATED) || (info == FILE_WAS_OVERWRITTEN)) {
3178                 if (allocation_size
3179                     && (allocation_size > fsp->fsp_name->st.st_ex_size)) {
3180                         fsp->initial_allocation_size = smb_roundup(
3181                                 fsp->conn, allocation_size);
3182                         if (fsp->is_directory) {
3183                                 /* Can't set allocation size on a directory. */
3184                                 status = NT_STATUS_ACCESS_DENIED;
3185                                 goto fail;
3186                         }
3187                         if (vfs_allocate_file_space(
3188                                     fsp, fsp->initial_allocation_size) == -1) {
3189                                 status = NT_STATUS_DISK_FULL;
3190                                 goto fail;
3191                         }
3192                 } else {
3193                         fsp->initial_allocation_size = smb_roundup(
3194                                 fsp->conn, (uint64_t)fsp->fsp_name->st.st_ex_size);
3195                 }
3196         }
3197
3198         DEBUG(10, ("create_file_unixpath: info=%d\n", info));
3199
3200         *result = fsp;
3201         if (pinfo != NULL) {
3202                 *pinfo = info;
3203         }
3204
3205         smb_fname->st = fsp->fsp_name->st;
3206
3207         return NT_STATUS_OK;
3208
3209  fail:
3210         DEBUG(10, ("create_file_unixpath: %s\n", nt_errstr(status)));
3211
3212         if (fsp != NULL) {
3213                 if (base_fsp && fsp->base_fsp == base_fsp) {
3214                         /*
3215                          * The close_file below will close
3216                          * fsp->base_fsp.
3217                          */
3218                         base_fsp = NULL;
3219                 }
3220                 close_file(req, fsp, ERROR_CLOSE);
3221                 fsp = NULL;
3222         }
3223         if (base_fsp != NULL) {
3224                 close_file(req, base_fsp, ERROR_CLOSE);
3225                 base_fsp = NULL;
3226         }
3227         return status;
3228 }
3229
3230 /*
3231  * Calculate the full path name given a relative fid.
3232  */
3233 NTSTATUS get_relative_fid_filename(connection_struct *conn,
3234                                    struct smb_request *req,
3235                                    uint16_t root_dir_fid,
3236                                    struct smb_filename *smb_fname)
3237 {
3238         files_struct *dir_fsp;
3239         char *parent_fname = NULL;
3240         char *new_base_name = NULL;
3241         NTSTATUS status;
3242
3243         if (root_dir_fid == 0 || !smb_fname) {
3244                 status = NT_STATUS_INTERNAL_ERROR;
3245                 goto out;
3246         }
3247
3248         dir_fsp = file_fsp(req, root_dir_fid);
3249
3250         if (dir_fsp == NULL) {
3251                 status = NT_STATUS_INVALID_HANDLE;
3252                 goto out;
3253         }
3254
3255         if (is_ntfs_stream_smb_fname(dir_fsp->fsp_name)) {
3256                 status = NT_STATUS_INVALID_HANDLE;
3257                 goto out;
3258         }
3259
3260         if (!dir_fsp->is_directory) {
3261
3262                 /*
3263                  * Check to see if this is a mac fork of some kind.
3264                  */
3265
3266                 if ((conn->fs_capabilities & FILE_NAMED_STREAMS) &&
3267                     is_ntfs_stream_smb_fname(smb_fname)) {
3268                         status = NT_STATUS_OBJECT_PATH_NOT_FOUND;
3269                         goto out;
3270                 }
3271
3272                 /*
3273                   we need to handle the case when we get a
3274                   relative open relative to a file and the
3275                   pathname is blank - this is a reopen!
3276                   (hint from demyn plantenberg)
3277                 */
3278
3279                 status = NT_STATUS_INVALID_HANDLE;
3280                 goto out;
3281         }
3282
3283         if (ISDOT(dir_fsp->fsp_name->base_name)) {
3284                 /*
3285                  * We're at the toplevel dir, the final file name
3286                  * must not contain ./, as this is filtered out
3287                  * normally by srvstr_get_path and unix_convert
3288                  * explicitly rejects paths containing ./.
3289                  */
3290                 parent_fname = talloc_strdup(talloc_tos(), "");
3291                 if (parent_fname == NULL) {
3292                         status = NT_STATUS_NO_MEMORY;
3293                         goto out;
3294                 }
3295         } else {
3296                 size_t dir_name_len = strlen(dir_fsp->fsp_name->base_name);
3297
3298                 /*
3299                  * Copy in the base directory name.
3300                  */
3301
3302                 parent_fname = TALLOC_ARRAY(talloc_tos(), char,
3303                     dir_name_len+2);
3304                 if (parent_fname == NULL) {
3305                         status = NT_STATUS_NO_MEMORY;
3306                         goto out;
3307                 }
3308                 memcpy(parent_fname, dir_fsp->fsp_name->base_name,
3309                     dir_name_len+1);
3310
3311                 /*
3312                  * Ensure it ends in a '/'.
3313                  * We used TALLOC_SIZE +2 to add space for the '/'.
3314                  */
3315
3316                 if(dir_name_len
3317                     && (parent_fname[dir_name_len-1] != '\\')
3318                     && (parent_fname[dir_name_len-1] != '/')) {
3319                         parent_fname[dir_name_len] = '/';
3320                         parent_fname[dir_name_len+1] = '\0';
3321                 }
3322         }
3323
3324         new_base_name = talloc_asprintf(smb_fname, "%s%s", parent_fname,
3325                                         smb_fname->base_name);
3326         if (new_base_name == NULL) {
3327                 status = NT_STATUS_NO_MEMORY;
3328                 goto out;
3329         }
3330
3331         TALLOC_FREE(smb_fname->base_name);
3332         smb_fname->base_name = new_base_name;
3333         status = NT_STATUS_OK;
3334
3335  out:
3336         TALLOC_FREE(parent_fname);
3337         return status;
3338 }
3339
3340 NTSTATUS create_file_default(connection_struct *conn,
3341                              struct smb_request *req,
3342                              uint16_t root_dir_fid,
3343                              struct smb_filename *smb_fname,
3344                              uint32_t access_mask,
3345                              uint32_t share_access,
3346                              uint32_t create_disposition,
3347                              uint32_t create_options,
3348                              uint32_t file_attributes,
3349                              uint32_t oplock_request,
3350                              uint64_t allocation_size,
3351                              struct security_descriptor *sd,
3352                              struct ea_list *ea_list,
3353                              files_struct **result,
3354                              int *pinfo)
3355 {
3356         int info = FILE_WAS_OPENED;
3357         files_struct *fsp = NULL;
3358         NTSTATUS status;
3359
3360         DEBUG(10,("create_file: access_mask = 0x%x "
3361                   "file_attributes = 0x%x, share_access = 0x%x, "
3362                   "create_disposition = 0x%x create_options = 0x%x "
3363                   "oplock_request = 0x%x "
3364                   "root_dir_fid = 0x%x, ea_list = 0x%p, sd = 0x%p, "
3365                   "fname = %s\n",
3366                   (unsigned int)access_mask,
3367                   (unsigned int)file_attributes,
3368                   (unsigned int)share_access,
3369                   (unsigned int)create_disposition,
3370                   (unsigned int)create_options,
3371                   (unsigned int)oplock_request,
3372                   (unsigned int)root_dir_fid,
3373                   ea_list, sd, smb_fname_str_dbg(smb_fname)));
3374
3375         /*
3376          * Calculate the filename from the root_dir_if if necessary.
3377          */
3378
3379         if (root_dir_fid != 0) {
3380                 status = get_relative_fid_filename(conn, req, root_dir_fid,
3381                                                    smb_fname);
3382                 if (!NT_STATUS_IS_OK(status)) {
3383                         goto fail;
3384                 }
3385         }
3386
3387         /*
3388          * Check to see if this is a mac fork of some kind.
3389          */
3390
3391         if (is_ntfs_stream_smb_fname(smb_fname)) {
3392                 enum FAKE_FILE_TYPE fake_file_type;
3393
3394                 fake_file_type = is_fake_file(smb_fname);
3395
3396                 if (fake_file_type != FAKE_FILE_TYPE_NONE) {
3397
3398                         /*
3399                          * Here we go! support for changing the disk quotas
3400                          * --metze
3401                          *
3402                          * We need to fake up to open this MAGIC QUOTA file
3403                          * and return a valid FID.
3404                          *
3405                          * w2k close this file directly after openening xp
3406                          * also tries a QUERY_FILE_INFO on the file and then
3407                          * close it
3408                          */
3409                         status = open_fake_file(req, conn, req->vuid,
3410                                                 fake_file_type, smb_fname,
3411                                                 access_mask, &fsp);
3412                         if (!NT_STATUS_IS_OK(status)) {
3413                                 goto fail;
3414                         }
3415
3416                         ZERO_STRUCT(smb_fname->st);
3417                         goto done;
3418                 }
3419
3420                 if (!(conn->fs_capabilities & FILE_NAMED_STREAMS)) {
3421                         status = NT_STATUS_OBJECT_NAME_NOT_FOUND;
3422                         goto fail;
3423                 }
3424         }
3425
3426         /* All file access must go through check_name() */
3427
3428         status = check_name(conn, smb_fname->base_name);
3429         if (!NT_STATUS_IS_OK(status)) {
3430                 goto fail;
3431         }
3432
3433         status = create_file_unixpath(
3434                 conn, req, smb_fname, access_mask, share_access,
3435                 create_disposition, create_options, file_attributes,
3436                 oplock_request, allocation_size, sd, ea_list,
3437                 &fsp, &info);
3438
3439         if (!NT_STATUS_IS_OK(status)) {
3440                 goto fail;
3441         }
3442
3443  done:
3444         DEBUG(10, ("create_file: info=%d\n", info));
3445
3446         *result = fsp;
3447         if (pinfo != NULL) {
3448                 *pinfo = info;
3449         }
3450         return NT_STATUS_OK;
3451
3452  fail:
3453         DEBUG(10, ("create_file: %s\n", nt_errstr(status)));
3454
3455         if (fsp != NULL) {
3456                 close_file(req, fsp, ERROR_CLOSE);
3457                 fsp = NULL;
3458         }
3459         return status;
3460 }