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         struct timeval request_time = timeval_zero();
1111         struct share_mode_lock *lck = NULL;
1112         NTSTATUS status;
1113
1114         if (conn->printer) {
1115                 /*
1116                  * Printers are handled completely differently.
1117                  * Most of the passed parameters are ignored.
1118                  */
1119
1120                 if (pinfo) {
1121                         *pinfo = FILE_WAS_CREATED;
1122                 }
1123
1124                 DEBUG(10, ("open_file_ntcreate: printer open fname=%s\n", fname));
1125
1126                 return print_fsp_open(conn, fname);
1127         }
1128
1129         /* We add aARCH to this as this mode is only used if the file is
1130          * created new. */
1131         unx_mode = unix_mode(conn, new_dos_attributes | aARCH,fname, True);
1132
1133         DEBUG(10, ("open_file_ntcreate: fname=%s, dos_attrs=0x%x "
1134                    "access_mask=0x%x share_access=0x%x "
1135                    "create_disposition = 0x%x create_options=0x%x "
1136                    "unix mode=0%o oplock_request=%d\n",
1137                    fname, new_dos_attributes, access_mask, share_access,
1138                    create_disposition, create_options, unx_mode,
1139                    oplock_request));
1140
1141         if ((pml = get_open_deferred_message(mid)) != NULL) {
1142                 struct deferred_open_record *state =
1143                         (struct deferred_open_record *)pml->private_data.data;
1144
1145                 /* Remember the absolute time of the original
1146                    request with this mid. We'll use it later to
1147                    see if this has timed out. */
1148
1149                 request_time = pml->request_time;
1150
1151                 /* Remove the deferred open entry under lock. */
1152                 lck = get_share_mode_lock(NULL, state->dev, state->inode, NULL, NULL);
1153                 if (lck == NULL) {
1154                         DEBUG(0, ("could not get share mode lock\n"));
1155                 } else {
1156                         del_deferred_open_entry(lck, mid);
1157                         TALLOC_FREE(lck);
1158                 }
1159
1160                 /* Ensure we don't reprocess this message. */
1161                 remove_deferred_open_smb_message(mid);
1162         }
1163
1164         if (!check_name(fname,conn)) {
1165                 return NULL;
1166         }
1167
1168         new_dos_attributes &= SAMBA_ATTRIBUTES_MASK;
1169         if (file_existed) {
1170                 existing_dos_attributes = dos_mode(conn, fname, psbuf);
1171         }
1172
1173         /* ignore any oplock requests if oplocks are disabled */
1174         if (!lp_oplocks(SNUM(conn)) || global_client_failed_oplock_break ||
1175             IS_VETO_OPLOCK_PATH(conn, fname)) {
1176                 /* Mask off everything except the private Samba bits. */
1177                 oplock_request &= SAMBA_PRIVATE_OPLOCK_MASK;
1178         }
1179
1180         /* this is for OS/2 long file names - say we don't support them */
1181         if (!lp_posix_pathnames() && strstr(fname,".+,;=[].")) {
1182                 /* OS/2 Workplace shell fix may be main code stream in a later
1183                  * release. */
1184                 set_saved_error_triple(ERRDOS, ERRcannotopen,
1185                                        NT_STATUS_OBJECT_NAME_NOT_FOUND);
1186                 DEBUG(5,("open_file_ntcreate: OS/2 long filenames are not "
1187                          "supported.\n"));
1188                 return NULL;
1189         }
1190
1191         switch( create_disposition ) {
1192                 /*
1193                  * Currently we're using FILE_SUPERSEDE as the same as
1194                  * FILE_OVERWRITE_IF but they really are
1195                  * different. FILE_SUPERSEDE deletes an existing file
1196                  * (requiring delete access) then recreates it.
1197                  */
1198                 case FILE_SUPERSEDE:
1199                         /* If file exists replace/overwrite. If file doesn't
1200                          * exist create. */
1201                         flags2 |= (O_CREAT | O_TRUNC);
1202                         break;
1203
1204                 case FILE_OVERWRITE_IF:
1205                         /* If file exists replace/overwrite. If file doesn't
1206                          * exist create. */
1207                         flags2 |= (O_CREAT | O_TRUNC);
1208                         break;
1209
1210                 case FILE_OPEN:
1211                         /* If file exists open. If file doesn't exist error. */
1212                         if (!file_existed) {
1213                                 DEBUG(5,("open_file_ntcreate: FILE_OPEN "
1214                                          "requested for file %s and file "
1215                                          "doesn't exist.\n", fname ));
1216                                 set_saved_ntstatus(NT_STATUS_OBJECT_NAME_NOT_FOUND);
1217                                 errno = ENOENT;
1218                                 return NULL;
1219                         }
1220                         break;
1221
1222                 case FILE_OVERWRITE:
1223                         /* If file exists overwrite. If file doesn't exist
1224                          * error. */
1225                         if (!file_existed) {
1226                                 DEBUG(5,("open_file_ntcreate: FILE_OVERWRITE "
1227                                          "requested for file %s and file "
1228                                          "doesn't exist.\n", fname ));
1229                                 set_saved_ntstatus(NT_STATUS_OBJECT_NAME_NOT_FOUND);
1230                                 errno = ENOENT;
1231                                 return NULL;
1232                         }
1233                         flags2 |= O_TRUNC;
1234                         break;
1235
1236                 case FILE_CREATE:
1237                         /* If file exists error. If file doesn't exist
1238                          * create. */
1239                         if (file_existed) {
1240                                 DEBUG(5,("open_file_ntcreate: FILE_CREATE "
1241                                          "requested for file %s and file "
1242                                          "already exists.\n", fname ));
1243                                 if (S_ISDIR(psbuf->st_mode)) {
1244                                         errno = EISDIR;
1245                                 } else {
1246                                         errno = EEXIST;
1247                                 }
1248                                 return NULL;
1249                         }
1250                         flags2 |= (O_CREAT|O_EXCL);
1251                         break;
1252
1253                 case FILE_OPEN_IF:
1254                         /* If file exists open. If file doesn't exist
1255                          * create. */
1256                         flags2 |= O_CREAT;
1257                         break;
1258
1259                 default:
1260                         set_saved_ntstatus(NT_STATUS_INVALID_PARAMETER);
1261                         return NULL;
1262         }
1263
1264         /* We only care about matching attributes on file exists and
1265          * overwrite. */
1266
1267         if (file_existed && ((create_disposition == FILE_OVERWRITE) ||
1268                              (create_disposition == FILE_OVERWRITE_IF))) {
1269                 if (!open_match_attributes(conn, fname,
1270                                            existing_dos_attributes,
1271                                            new_dos_attributes, psbuf->st_mode,
1272                                            unx_mode, &new_unx_mode)) {
1273                         DEBUG(5,("open_file_ntcreate: attributes missmatch "
1274                                  "for file %s (%x %x) (0%o, 0%o)\n",
1275                                  fname, existing_dos_attributes,
1276                                  new_dos_attributes,
1277                                  (unsigned int)psbuf->st_mode,
1278                                  (unsigned int)unx_mode ));
1279                         errno = EACCES;
1280                         return NULL;
1281                 }
1282         }
1283
1284         /* This is a nasty hack - must fix... JRA. */
1285         if (access_mask == MAXIMUM_ALLOWED_ACCESS) {
1286                 access_mask = FILE_GENERIC_ALL;
1287         }
1288
1289         /*
1290          * Convert GENERIC bits to specific bits.
1291          */
1292
1293         se_map_generic(&access_mask, &file_generic_mapping);
1294
1295         DEBUG(10, ("open_file_ntcreate: fname=%s, after mapping "
1296                    "access_mask=0x%x\n", fname, access_mask ));
1297
1298         /*
1299          * Note that we ignore the append flag as append does not
1300          * mean the same thing under DOS and Unix.
1301          */
1302
1303         if (access_mask & (FILE_WRITE_DATA | FILE_APPEND_DATA)) {
1304                 flags = O_RDWR;
1305         } else {
1306                 flags = O_RDONLY;
1307         }
1308
1309         /*
1310          * Currently we only look at FILE_WRITE_THROUGH for create options.
1311          */
1312
1313 #if defined(O_SYNC)
1314         if ((create_options & FILE_WRITE_THROUGH) && lp_strict_sync(SNUM(conn))) {
1315                 flags2 |= O_SYNC;
1316         }
1317 #endif /* O_SYNC */
1318
1319         if (!CAN_WRITE(conn)) {
1320                 /*
1321                  * We should really return a permission denied error if either
1322                  * O_CREAT or O_TRUNC are set, but for compatibility with
1323                  * older versions of Samba we just AND them out.
1324                  */
1325                 flags2 &= ~(O_CREAT|O_TRUNC);
1326         }
1327
1328         /*
1329          * Ensure we can't write on a read-only share or file.
1330          */
1331
1332         if (flags != O_RDONLY && file_existed &&
1333             (!CAN_WRITE(conn) || IS_DOS_READONLY(existing_dos_attributes))) {
1334                 DEBUG(5,("open_file_ntcreate: write access requested for "
1335                          "file %s on read only %s\n",
1336                          fname, !CAN_WRITE(conn) ? "share" : "file" ));
1337                 set_saved_ntstatus(NT_STATUS_ACCESS_DENIED);
1338                 errno = EACCES;
1339                 return NULL;
1340         }
1341
1342         fsp = file_new(conn);
1343         if(!fsp) {
1344                 return NULL;
1345         }
1346
1347         fsp->dev = psbuf->st_dev;
1348         fsp->inode = psbuf->st_ino;
1349         fsp->share_access = share_access;
1350         fsp->fh->private_options = create_options;
1351         fsp->access_mask = access_mask;
1352         /* Ensure no SAMBA_PRIVATE bits can be set. */
1353         fsp->oplock_type = (oplock_request & ~SAMBA_PRIVATE_OPLOCK_MASK);
1354
1355         if (timeval_is_zero(&request_time)) {
1356                 request_time = fsp->open_time;
1357         }
1358
1359         if (file_existed) {
1360                 dev = psbuf->st_dev;
1361                 inode = psbuf->st_ino;
1362
1363                 lck = get_share_mode_lock(NULL, dev, inode,
1364                                         conn->connectpath,
1365                                         fname);
1366
1367                 if (lck == NULL) {
1368                         file_free(fsp);
1369                         DEBUG(0, ("Could not get share mode lock\n"));
1370                         set_saved_ntstatus(NT_STATUS_SHARING_VIOLATION);
1371                         return NULL;
1372                 }
1373
1374                 /* First pass - send break only on batch oplocks. */
1375                 if (delay_for_oplocks(lck, fsp, 1, oplock_request)) {
1376                         schedule_defer_open(lck, request_time);
1377                         TALLOC_FREE(lck);
1378                         file_free(fsp);
1379                         return NULL;
1380                 }
1381
1382                 status = open_mode_check(conn, fname, lck,
1383                                          access_mask, share_access,
1384                                          create_options, &file_existed);
1385
1386                 if (NT_STATUS_IS_OK(status)) {
1387                         /* We might be going to allow this open. Check oplock status again. */
1388                         /* Second pass - send break for both batch or exclusive oplocks. */
1389                         if (delay_for_oplocks(lck, fsp, 2, oplock_request)) {
1390                                 schedule_defer_open(lck, request_time);
1391                                 TALLOC_FREE(lck);
1392                                 file_free(fsp);
1393                                 return NULL;
1394                         }
1395                 }
1396
1397                 if (NT_STATUS_EQUAL(status, NT_STATUS_DELETE_PENDING)) {
1398                         /* DELETE_PENDING is not deferred for a second */
1399                         set_saved_ntstatus(status);
1400                         TALLOC_FREE(lck);
1401                         file_free(fsp);
1402                         return NULL;
1403                 }
1404
1405                 if (!NT_STATUS_IS_OK(status)) {
1406
1407                         SMB_ASSERT(NT_STATUS_EQUAL(status, NT_STATUS_SHARING_VIOLATION));
1408
1409                         /* Check if this can be done with the deny_dos and fcb
1410                          * calls. */
1411                         if (create_options &
1412                             (NTCREATEX_OPTIONS_PRIVATE_DENY_DOS|
1413                              NTCREATEX_OPTIONS_PRIVATE_DENY_FCB)) {
1414                                 files_struct *fsp_dup;
1415                                 fsp_dup = fcb_or_dos_open(conn, fname, dev,
1416                                                           inode, access_mask,
1417                                                           share_access,
1418                                                           create_options);
1419
1420                                 if (fsp_dup) {
1421                                         TALLOC_FREE(lck);
1422                                         file_free(fsp);
1423                                         if (pinfo) {
1424                                                 *pinfo = FILE_WAS_OPENED;
1425                                         }
1426                                         conn->num_files_open++;
1427                                         return fsp_dup;
1428                                 }
1429                         }
1430
1431                         /*
1432                          * This next line is a subtlety we need for
1433                          * MS-Access. If a file open will fail due to share
1434                          * permissions and also for security (access) reasons,
1435                          * we need to return the access failed error, not the
1436                          * share error. This means we must attempt to open the
1437                          * file anyway in order to get the UNIX access error -
1438                          * even if we're going to fail the open for share
1439                          * reasons. This is bad, as we're burning another fd
1440                          * if there are existing locks but there's nothing
1441                          * else we can do. We also ensure we're not going to
1442                          * create or tuncate the file as we only want an
1443                          * access decision at this stage. JRA.
1444                          */
1445                         errno = 0;
1446                         fsp_open = open_file(fsp,conn,fname,psbuf,
1447                                              flags|(flags2&~(O_TRUNC|O_CREAT)),
1448                                              unx_mode,access_mask);
1449
1450                         DEBUG(4,("open_file_ntcreate : share_mode deny - "
1451                                  "calling open_file with flags=0x%X "
1452                                  "flags2=0x%X mode=0%o returned %d\n",
1453                                  flags, (flags2&~(O_TRUNC|O_CREAT)),
1454                                  (unsigned int)unx_mode, (int)fsp_open ));
1455
1456                         if (!fsp_open && errno) {
1457                                 /* Default error. */
1458                                 set_saved_ntstatus(NT_STATUS_ACCESS_DENIED);
1459                         }
1460
1461                         /*
1462                          * If we're returning a share violation, ensure we
1463                          * cope with the braindead 1 second delay.
1464                          */
1465
1466                         if (!(oplock_request & INTERNAL_OPEN_ONLY) &&
1467                             lp_defer_sharing_violations()) {
1468                                 struct timeval timeout;
1469                                 struct deferred_open_record state;
1470                                 int timeout_usecs;
1471
1472                                 /* this is a hack to speed up torture tests
1473                                    in 'make test' */
1474                                 timeout_usecs = lp_parm_int(conn->service,
1475                                                             "smbd","sharedelay",
1476                                                             SHARING_VIOLATION_USEC_WAIT);
1477
1478                                 /* This is a relative time, added to the absolute
1479                                    request_time value to get the absolute timeout time.
1480                                    Note that if this is the second or greater time we enter
1481                                    this codepath for this particular request mid then
1482                                    request_time is left as the absolute time of the *first*
1483                                    time this request mid was processed. This is what allows
1484                                    the request to eventually time out. */
1485
1486                                 timeout = timeval_set(0, timeout_usecs);
1487
1488                                 /* Nothing actually uses state.delayed_for_oplocks
1489                                    but it's handy to differentiate in debug messages
1490                                    between a 30 second delay due to oplock break, and
1491                                    a 1 second delay for share mode conflicts. */
1492
1493                                 state.delayed_for_oplocks = False;
1494                                 state.dev = dev;
1495                                 state.inode = inode;
1496
1497                                 if (!request_timed_out(request_time,
1498                                                        timeout)) {
1499                                         defer_open(lck, request_time, timeout,
1500                                                    &state);
1501                                 }
1502                         }
1503
1504                         TALLOC_FREE(lck);
1505                         if (fsp_open) {
1506                                 fd_close(conn, fsp);
1507                                 /*
1508                                  * We have detected a sharing violation here
1509                                  * so return the correct error code
1510                                  */
1511                                 set_saved_ntstatus(NT_STATUS_SHARING_VIOLATION);
1512                         }
1513                         file_free(fsp);
1514                         return NULL;
1515                 }
1516
1517                 /*
1518                  * We exit this block with the share entry *locked*.....
1519                  */
1520         }
1521
1522         SMB_ASSERT(!file_existed || (lck != NULL));
1523
1524         /*
1525          * Ensure we pay attention to default ACLs on directories if required.
1526          */
1527
1528         if ((flags2 & O_CREAT) && lp_inherit_acls(SNUM(conn)) &&
1529             (def_acl = directory_has_default_acl(conn,
1530                                                  parent_dirname(fname)))) {
1531                 unx_mode = 0777;
1532         }
1533
1534         DEBUG(4,("calling open_file with flags=0x%X flags2=0x%X mode=0%o\n",
1535                  (unsigned int)flags, (unsigned int)flags2,
1536                  (unsigned int)unx_mode));
1537
1538         /*
1539          * open_file strips any O_TRUNC flags itself.
1540          */
1541
1542         fsp_open = open_file(fsp,conn,fname,psbuf,flags|flags2,unx_mode,
1543                              access_mask);
1544
1545         if (!fsp_open) {
1546                 if (lck != NULL) {
1547                         TALLOC_FREE(lck);
1548                 }
1549                 file_free(fsp);
1550                 return NULL;
1551         }
1552
1553         if (!file_existed) {
1554
1555                 /*
1556                  * Deal with the race condition where two smbd's detect the
1557                  * file doesn't exist and do the create at the same time. One
1558                  * of them will win and set a share mode, the other (ie. this
1559                  * one) should check if the requested share mode for this
1560                  * create is allowed.
1561                  */
1562
1563                 /*
1564                  * Now the file exists and fsp is successfully opened,
1565                  * fsp->dev and fsp->inode are valid and should replace the
1566                  * dev=0,inode=0 from a non existent file. Spotted by
1567                  * Nadav Danieli <nadavd@exanet.com>. JRA.
1568                  */
1569
1570                 dev = fsp->dev;
1571                 inode = fsp->inode;
1572
1573                 lck = get_share_mode_lock(NULL, dev, inode,
1574                                         conn->connectpath,
1575                                         fname);
1576
1577                 if (lck == NULL) {
1578                         DEBUG(0, ("open_file_ntcreate: Could not get share mode lock for %s\n", fname));
1579                         fd_close(conn, fsp);
1580                         file_free(fsp);
1581                         set_saved_ntstatus(NT_STATUS_SHARING_VIOLATION);
1582                         return NULL;
1583                 }
1584
1585                 status = open_mode_check(conn, fname, lck,
1586                                          access_mask, share_access,
1587                                          create_options, &file_existed);
1588
1589                 if (!NT_STATUS_IS_OK(status)) {
1590                         struct deferred_open_record state;
1591
1592                         fd_close(conn, fsp);
1593                         file_free(fsp);
1594
1595                         state.delayed_for_oplocks = False;
1596                         state.dev = dev;
1597                         state.inode = inode;
1598
1599                         /* Do it all over again immediately. In the second
1600                          * round we will find that the file existed and handle
1601                          * the DELETE_PENDING and FCB cases correctly. No need
1602                          * to duplicate the code here. Essentially this is a
1603                          * "goto top of this function", but don't tell
1604                          * anybody... */
1605
1606                         defer_open(lck, request_time, timeval_zero(),
1607                                    &state);
1608                         TALLOC_FREE(lck);
1609                         return NULL;
1610                 }
1611
1612                 /*
1613                  * We exit this block with the share entry *locked*.....
1614                  */
1615         }
1616
1617         SMB_ASSERT(lck != NULL);
1618
1619         /* note that we ignore failure for the following. It is
1620            basically a hack for NFS, and NFS will never set one of
1621            these only read them. Nobody but Samba can ever set a deny
1622            mode and we have already checked our more authoritative
1623            locking database for permission to set this deny mode. If
1624            the kernel refuses the operations then the kernel is wrong */
1625
1626         kernel_flock(fsp, share_access);
1627
1628         /*
1629          * At this point onwards, we can guarentee that the share entry
1630          * is locked, whether we created the file or not, and that the
1631          * deny mode is compatible with all current opens.
1632          */
1633
1634         /*
1635          * If requested, truncate the file.
1636          */
1637
1638         if (flags2&O_TRUNC) {
1639                 /*
1640                  * We are modifing the file after open - update the stat
1641                  * struct..
1642                  */
1643                 if ((SMB_VFS_FTRUNCATE(fsp,fsp->fh->fd,0) == -1) ||
1644                     (SMB_VFS_FSTAT(fsp,fsp->fh->fd,psbuf)==-1)) {
1645                         TALLOC_FREE(lck);
1646                         fd_close(conn,fsp);
1647                         file_free(fsp);
1648                         return NULL;
1649                 }
1650         }
1651
1652         /* Record the options we were opened with. */
1653         fsp->share_access = share_access;
1654         fsp->fh->private_options = create_options;
1655         fsp->access_mask = access_mask;
1656
1657         if (file_existed) {
1658                 if (!(flags2 & O_TRUNC)) {
1659                         info = FILE_WAS_OPENED;
1660                 } else {
1661                         info = FILE_WAS_OVERWRITTEN;
1662                 }
1663         } else {
1664                 info = FILE_WAS_CREATED;
1665                 /* Change the owner if required. */
1666                 if (lp_inherit_owner(SNUM(conn))) {
1667                         change_owner_to_parent(conn, fsp, fsp->fsp_name,
1668                                                psbuf);
1669                 }
1670         }
1671
1672         if (pinfo) {
1673                 *pinfo = info;
1674         }
1675
1676         /*
1677          * Setup the oplock info in both the shared memory and
1678          * file structs.
1679          */
1680
1681         if ((fsp->oplock_type != NO_OPLOCK) &&
1682             (fsp->oplock_type != FAKE_LEVEL_II_OPLOCK)) {
1683                 if (!set_file_oplock(fsp, fsp->oplock_type)) {
1684                         /* Could not get the kernel oplock */
1685                         fsp->oplock_type = NO_OPLOCK;
1686                 }
1687         }
1688         set_share_mode(lck, fsp, current_user.ut.uid, 0, fsp->oplock_type);
1689
1690         if (info == FILE_WAS_OVERWRITTEN || info == FILE_WAS_CREATED ||
1691                                 info == FILE_WAS_SUPERSEDED) {
1692
1693                 /* Handle strange delete on close create semantics. */
1694                 if (create_options & FILE_DELETE_ON_CLOSE) {
1695                         NTSTATUS result = can_set_delete_on_close(fsp, True, new_dos_attributes);
1696
1697                         if (!NT_STATUS_IS_OK(result)) {
1698                                 /* Remember to delete the mode we just added. */
1699                                 del_share_mode(lck, fsp);
1700                                 TALLOC_FREE(lck);
1701                                 fd_close(conn,fsp);
1702                                 file_free(fsp);
1703                                 set_saved_ntstatus(result);
1704                                 return NULL;
1705                         }
1706                         /* Note that here we set the *inital* delete on close flag,
1707                            not the regular one. */
1708                         set_delete_on_close_token(lck, &current_user.ut);
1709                         lck->initial_delete_on_close = True;
1710                         lck->modified = True;
1711                 }
1712
1713                 /* Files should be initially set as archive */
1714                 if (lp_map_archive(SNUM(conn)) ||
1715                     lp_store_dos_attributes(SNUM(conn))) {
1716                         file_set_dosmode(conn, fname,
1717                                          new_dos_attributes | aARCH, NULL,
1718                                          True);
1719                 }
1720         }
1721
1722         /*
1723          * Take care of inherited ACLs on created files - if default ACL not
1724          * selected.
1725          */
1726
1727         if (!file_existed && !def_acl) {
1728
1729                 int saved_errno = errno; /* We might get ENOSYS in the next
1730                                           * call.. */
1731
1732                 if (SMB_VFS_FCHMOD_ACL(fsp, fsp->fh->fd, unx_mode) == -1
1733                     && errno == ENOSYS) {
1734                         errno = saved_errno; /* Ignore ENOSYS */
1735                 }
1736
1737         } else if (new_unx_mode) {
1738
1739                 int ret = -1;
1740
1741                 /* Attributes need changing. File already existed. */
1742
1743                 {
1744                         int saved_errno = errno; /* We might get ENOSYS in the
1745                                                   * next call.. */
1746                         ret = SMB_VFS_FCHMOD_ACL(fsp, fsp->fh->fd,
1747                                                  new_unx_mode);
1748
1749                         if (ret == -1 && errno == ENOSYS) {
1750                                 errno = saved_errno; /* Ignore ENOSYS */
1751                         } else {
1752                                 DEBUG(5, ("open_file_ntcreate: reset "
1753                                           "attributes of file %s to 0%o\n",
1754                                         fname, (unsigned int)new_unx_mode));
1755                                 ret = 0; /* Don't do the fchmod below. */
1756                         }
1757                 }
1758
1759                 if ((ret == -1) &&
1760                     (SMB_VFS_FCHMOD(fsp, fsp->fh->fd, new_unx_mode) == -1))
1761                         DEBUG(5, ("open_file_ntcreate: failed to reset "
1762                                   "attributes of file %s to 0%o\n",
1763                                 fname, (unsigned int)new_unx_mode));
1764         }
1765
1766         /* If this is a successful open, we must remove any deferred open
1767          * records. */
1768         del_deferred_open_entry(lck, mid);
1769         TALLOC_FREE(lck);
1770
1771         conn->num_files_open++;
1772
1773         return fsp;
1774 }
1775
1776 /****************************************************************************
1777  Open a file for for write to ensure that we can fchmod it.
1778 ****************************************************************************/
1779
1780 files_struct *open_file_fchmod(connection_struct *conn, const char *fname,
1781                                SMB_STRUCT_STAT *psbuf)
1782 {
1783         files_struct *fsp = NULL;
1784         BOOL fsp_open;
1785
1786         if (!VALID_STAT(*psbuf)) {
1787                 return NULL;
1788         }
1789
1790         fsp = file_new(conn);
1791         if(!fsp) {
1792                 return NULL;
1793         }
1794
1795         /* note! we must use a non-zero desired access or we don't get
1796            a real file descriptor. Oh what a twisted web we weave. */
1797         fsp_open = open_file(fsp,conn,fname,psbuf,O_WRONLY,0,FILE_WRITE_DATA);
1798
1799         /*
1800          * This is not a user visible file open.
1801          * Don't set a share mode and don't increment
1802          * the conn->num_files_open.
1803          */
1804
1805         if (!fsp_open) {
1806                 file_free(fsp);
1807                 return NULL;
1808         }
1809
1810         return fsp;
1811 }
1812
1813 /****************************************************************************
1814  Close the fchmod file fd - ensure no locks are lost.
1815 ****************************************************************************/
1816
1817 int close_file_fchmod(files_struct *fsp)
1818 {
1819         int ret = fd_close(fsp->conn, fsp);
1820         file_free(fsp);
1821         return ret;
1822 }
1823
1824 /****************************************************************************
1825  Open a directory from an NT SMB call.
1826 ****************************************************************************/
1827
1828 files_struct *open_directory(connection_struct *conn,
1829                                 const char *fname,
1830                                 SMB_STRUCT_STAT *psbuf,
1831                                 uint32 access_mask,
1832                                 uint32 share_access,
1833                                 uint32 create_disposition,
1834                                 uint32 create_options,
1835                                 int *pinfo)
1836 {
1837         files_struct *fsp = NULL;
1838         BOOL dir_existed = VALID_STAT(*psbuf) ? True : False;
1839         BOOL create_dir = False;
1840         struct share_mode_lock *lck = NULL;
1841         NTSTATUS status;
1842         int info = 0;
1843
1844         DEBUG(5,("open_directory: opening directory %s, access_mask = 0x%x, "
1845                  "share_access = 0x%x create_options = 0x%x, "
1846                  "create_disposition = 0x%x\n",
1847                  fname,
1848                  (unsigned int)access_mask,
1849                  (unsigned int)share_access,
1850                  (unsigned int)create_options,
1851                  (unsigned int)create_disposition));
1852
1853         if (is_ntfs_stream_name(fname)) {
1854                 DEBUG(0,("open_directory: %s is a stream name!\n", fname ));
1855                 set_saved_ntstatus(NT_STATUS_NOT_A_DIRECTORY);
1856                 return NULL;
1857         }
1858
1859         switch( create_disposition ) {
1860                 case FILE_OPEN:
1861                         /* If directory exists open. If directory doesn't
1862                          * exist error. */
1863                         if (!dir_existed) {
1864                                 DEBUG(5,("open_directory: FILE_OPEN requested "
1865                                          "for directory %s and it doesn't "
1866                                          "exist.\n", fname ));
1867                                 set_saved_ntstatus(NT_STATUS_OBJECT_NAME_NOT_FOUND);
1868                                 return NULL;
1869                         }
1870                         info = FILE_WAS_OPENED;
1871                         break;
1872
1873                 case FILE_CREATE:
1874                         /* If directory exists error. If directory doesn't
1875                          * exist create. */
1876                         if (dir_existed) {
1877                                 DEBUG(5,("open_directory: FILE_CREATE "
1878                                          "requested for directory %s and it "
1879                                          "already exists.\n", fname ));
1880                                 set_saved_error_triple(ERRDOS, ERRfilexists,
1881                                                        NT_STATUS_OBJECT_NAME_COLLISION);
1882                                 return NULL;
1883                         }
1884                         create_dir = True;
1885                         info = FILE_WAS_CREATED;
1886                         break;
1887
1888                 case FILE_OPEN_IF:
1889                         /* If directory exists open. If directory doesn't
1890                          * exist create. */
1891                         if (!dir_existed) {
1892                                 create_dir = True;
1893                                 info = FILE_WAS_CREATED;
1894                         } else {
1895                                 info = FILE_WAS_OPENED;
1896                         }
1897                         break;
1898
1899                 case FILE_SUPERSEDE:
1900                 case FILE_OVERWRITE:
1901                 case FILE_OVERWRITE_IF:
1902                 default:
1903                         DEBUG(5,("open_directory: invalid create_disposition "
1904                                  "0x%x for directory %s\n",
1905                                  (unsigned int)create_disposition, fname));
1906                         set_saved_ntstatus(NT_STATUS_INVALID_PARAMETER);
1907                         return NULL;
1908         }
1909
1910         if (create_dir) {
1911                 /*
1912                  * Try and create the directory.
1913                  */
1914
1915                 /* We know bad_path is false as it's caught earlier. */
1916
1917                 status = mkdir_internal(conn, fname, False);
1918
1919                 if (!NT_STATUS_IS_OK(status)) {
1920                         DEBUG(2,("open_directory: unable to create %s. "
1921                                  "Error was %s\n", fname, strerror(errno) ));
1922                         /* Ensure we return the correct NT status to the
1923                          * client. */
1924                         set_saved_error_triple(0, 0, status);
1925                         return NULL;
1926                 }
1927
1928                 /* Ensure we're checking for a symlink here.... */
1929                 /* We don't want to get caught by a symlink racer. */
1930
1931                 if(SMB_VFS_LSTAT(conn,fname, psbuf) != 0) {
1932                         return NULL;
1933                 }
1934
1935                 if(!S_ISDIR(psbuf->st_mode)) {
1936                         DEBUG(0,("open_directory: %s is not a directory !\n",
1937                                  fname ));
1938                         return NULL;
1939                 }
1940         }
1941
1942         fsp = file_new(conn);
1943         if(!fsp) {
1944                 return NULL;
1945         }
1946
1947         /*
1948          * Setup the files_struct for it.
1949          */
1950
1951         fsp->mode = psbuf->st_mode;
1952         fsp->inode = psbuf->st_ino;
1953         fsp->dev = psbuf->st_dev;
1954         fsp->vuid = current_user.vuid;
1955         fsp->file_pid = global_smbpid;
1956         fsp->can_lock = True;
1957         fsp->can_read = False;
1958         fsp->can_write = False;
1959
1960         fsp->share_access = share_access;
1961         fsp->fh->private_options = create_options;
1962         fsp->access_mask = access_mask;
1963
1964         fsp->print_file = False;
1965         fsp->modified = False;
1966         fsp->oplock_type = NO_OPLOCK;
1967         fsp->sent_oplock_break = NO_BREAK_SENT;
1968         fsp->is_directory = True;
1969         fsp->is_stat = False;
1970         string_set(&fsp->fsp_name,fname);
1971
1972         lck = get_share_mode_lock(NULL, fsp->dev, fsp->inode,
1973                                 conn->connectpath,
1974                                 fname);
1975
1976         if (lck == NULL) {
1977                 DEBUG(0, ("open_directory: Could not get share mode lock for %s\n", fname));
1978                 file_free(fsp);
1979                 set_saved_ntstatus(NT_STATUS_SHARING_VIOLATION);
1980                 return NULL;
1981         }
1982
1983         status = open_mode_check(conn, fname, lck,
1984                                 access_mask, share_access,
1985                                 create_options, &dir_existed);
1986
1987         if (!NT_STATUS_IS_OK(status)) {
1988                 set_saved_ntstatus(status);
1989                 TALLOC_FREE(lck);
1990                 file_free(fsp);
1991                 return NULL;
1992         }
1993
1994         set_share_mode(lck, fsp, current_user.ut.uid, 0, NO_OPLOCK);
1995
1996         /* For directories the delete on close bit at open time seems
1997            always to be honored on close... See test 19 in Samba4 BASE-DELETE. */
1998         if (create_options & FILE_DELETE_ON_CLOSE) {
1999                 status = can_set_delete_on_close(fsp, True, 0);
2000                 if (!NT_STATUS_IS_OK(status)) {
2001                         set_saved_ntstatus(status);
2002                         TALLOC_FREE(lck);
2003                         file_free(fsp);
2004                         return NULL;
2005                 }
2006
2007                 set_delete_on_close_token(lck, &current_user.ut);
2008                 lck->initial_delete_on_close = True;
2009                 lck->modified = True;
2010         }
2011
2012         TALLOC_FREE(lck);
2013
2014         /* Change the owner if required. */
2015         if ((info == FILE_WAS_CREATED) && lp_inherit_owner(SNUM(conn))) {
2016                 change_owner_to_parent(conn, fsp, fsp->fsp_name, psbuf);
2017         }
2018
2019         if (pinfo) {
2020                 *pinfo = info;
2021         }
2022
2023         conn->num_files_open++;
2024
2025         return fsp;
2026 }
2027
2028 /****************************************************************************
2029  Open a pseudo-file (no locking checks - a 'stat' open).
2030 ****************************************************************************/
2031
2032 files_struct *open_file_stat(connection_struct *conn, char *fname,
2033                              SMB_STRUCT_STAT *psbuf)
2034 {
2035         files_struct *fsp = NULL;
2036
2037         if (!VALID_STAT(*psbuf))
2038                 return NULL;
2039
2040         /* Can't 'stat' open directories. */
2041         if(S_ISDIR(psbuf->st_mode))
2042                 return NULL;
2043
2044         fsp = file_new(conn);
2045         if(!fsp)
2046                 return NULL;
2047
2048         DEBUG(5,("open_file_stat: 'opening' file %s\n", fname));
2049
2050         /*
2051          * Setup the files_struct for it.
2052          */
2053
2054         fsp->mode = psbuf->st_mode;
2055         fsp->inode = psbuf->st_ino;
2056         fsp->dev = psbuf->st_dev;
2057         fsp->vuid = current_user.vuid;
2058         fsp->file_pid = global_smbpid;
2059         fsp->can_lock = False;
2060         fsp->can_read = False;
2061         fsp->can_write = False;
2062         fsp->print_file = False;
2063         fsp->modified = False;
2064         fsp->oplock_type = NO_OPLOCK;
2065         fsp->sent_oplock_break = NO_BREAK_SENT;
2066         fsp->is_directory = False;
2067         fsp->is_stat = True;
2068         string_set(&fsp->fsp_name,fname);
2069
2070         conn->num_files_open++;
2071
2072         return fsp;
2073 }
2074
2075 /****************************************************************************
2076  Receive notification that one of our open files has been renamed by another
2077  smbd process.
2078 ****************************************************************************/
2079
2080 void msg_file_was_renamed(int msg_type, struct process_id src, void *buf, size_t len)
2081 {
2082         files_struct *fsp;
2083         char *frm = (char *)buf;
2084         SMB_DEV_T dev;
2085         SMB_INO_T inode;
2086         const char *sharepath;
2087         const char *newname;
2088         size_t sp_len;
2089
2090         if (buf == NULL || len < MSG_FILE_RENAMED_MIN_SIZE + 2) {
2091                 DEBUG(0, ("msg_file_was_renamed: Got invalid msg len %d\n", (int)len));
2092                 return;
2093         }
2094
2095         /* Unpack the message. */
2096         dev = DEV_T_VAL(frm,0);
2097         inode = INO_T_VAL(frm,8);
2098         sharepath = &frm[16];
2099         newname = sharepath + strlen(sharepath) + 1;
2100         sp_len = strlen(sharepath);
2101
2102         DEBUG(10,("msg_file_was_renamed: Got rename message for sharepath %s, new name %s, "
2103                 "dev %x, inode  %.0f\n",
2104                 sharepath, newname, (unsigned int)dev, (double)inode ));
2105
2106         for(fsp = file_find_di_first(dev, inode); fsp; fsp = file_find_di_next(fsp)) {
2107                 if (memcmp(fsp->conn->connectpath, sharepath, sp_len) == 0) {
2108                         DEBUG(10,("msg_file_was_renamed: renaming file fnum %d from %s -> %s\n",
2109                                 fsp->fnum, fsp->fsp_name, newname ));
2110                         string_set(&fsp->fsp_name, newname);
2111                 } else {
2112                         /* TODO. JRA. */
2113                         /* Now we have the complete path we can work out if this is
2114                            actually within this share and adjust newname accordingly. */
2115                         DEBUG(10,("msg_file_was_renamed: share mismatch (sharepath %s "
2116                                 "not sharepath %s) "
2117                                 "fnum %d from %s -> %s\n",
2118                                 fsp->conn->connectpath,
2119                                 sharepath,
2120                                 fsp->fnum,
2121                                 fsp->fsp_name,
2122                                 newname ));
2123                 }
2124         }
2125 }