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