source/smbd/open.c

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