source3/smbd/open.c

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