source/smbd/open.c

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