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, num_level2;
 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         num_level2 = 0;
 642
 643         if (lck->num_share_modes == 0) {
 644                 /* No files open at all: Directly grant whatever the client
 645                  * wants. */
 646
 647                 if (fsp->oplock_type == NO_OPLOCK) {
 648                         /* Store a level2 oplock, but don't tell the client */
 649                         fsp->oplock_type = FAKE_LEVEL_II_OPLOCK;
 650                 }
 651                 return False;
 652         }
 653
 654         for (i=0; i<lck->num_share_modes; i++) {
 655
 656                 if (!is_valid_share_mode_entry(&lck->share_modes[i])) {
 657                         continue;
 658                 }
 659
 660                 if (EXCLUSIVE_OPLOCK_TYPE(lck->share_modes[i].op_type)) {
 661                         SMB_ASSERT(exclusive == NULL);
 662                         exclusive = &lck->share_modes[i];
 663                 }
 664
 665                 if (lck->share_modes[i].op_type == LEVEL_II_OPLOCK) {
 666                         have_level2 = True;
 667                 }
 668         }
 669
 670         if (exclusive != NULL) { /* Found an exclusive oplock */
 671                 SMB_ASSERT(!have_level2);
 672                 delay_it = is_delete_request(fsp) ?
 673                         BATCH_OPLOCK_TYPE(exclusive->op_type) : True;
 674         }
 675
 676         if (EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type)) {
 677                 /* We can at most grant level2 */
 678                 fsp->oplock_type = LEVEL_II_OPLOCK;
 679         }
 680
 681         if ((fsp->oplock_type == NO_OPLOCK) && have_level2) {
 682                 /* Store a level2 oplock, but don't tell the client */
 683                 fsp->oplock_type = FAKE_LEVEL_II_OPLOCK;
 684         }
 685
 686         if (delay_it) {
 687                 DEBUG(10, ("Sending break request to PID %s\n",
 688                            procid_str_static(&exclusive->pid)));
 689                 exclusive->op_mid = get_current_mid();
 690                 if (!message_send_pid(exclusive->pid, MSG_SMB_BREAK_REQUEST,
 691                                       exclusive, sizeof(*exclusive), True)) {
 692                         DEBUG(3, ("Could not send oplock break message\n"));
 693                 }
 694                 file_free(fsp);
 695         }
 696
 697         return delay_it;
 698 }
 699
 700 static BOOL request_timed_out(struct timeval request_time,
 701                               struct timeval timeout)
 702 {
 703         struct timeval now, end_time;
 704         GetTimeOfDay(&now);
 705         end_time = timeval_sum(&request_time, &timeout);
 706         return (timeval_compare(&end_time, &now) < 0);
 707 }
 708
 709 /****************************************************************************
 710  Handle the 1 second delay in returning a SHARING_VIOLATION error.
 711 ****************************************************************************/
 712
 713 static void defer_open(struct share_mode_lock *lck,
 714                        struct timeval request_time,
 715                        struct timeval timeout,
 716                        struct deferred_open_record *state)
 717 {
 718         uint16 mid = get_current_mid();
 719         int i;
 720
 721         /* Paranoia check */
 722
 723         for (i=0; i<lck->num_share_modes; i++) {
 724                 struct share_mode_entry *e = &lck->share_modes[i];
 725
 726                 if (!is_deferred_open_entry(e)) {
 727                         continue;
 728                 }
 729
 730                 if (procid_is_me(&e->pid) && (e->op_mid == mid)) {
 731                         DEBUG(0, ("Trying to defer an already deferred "
 732                                   "request: mid=%d, exiting\n", mid));
 733                         exit_server("exiting");
 734                 }
 735         }
 736
 737         /* End paranoia check */
 738
 739         DEBUG(10,("defer_open_sharing_error: time [%u.%06u] adding deferred "
 740                   "open entry for mid %u\n",
 741                   (unsigned int)request_time.tv_sec,
 742                   (unsigned int)request_time.tv_usec,
 743                   (unsigned int)mid));
 744
 745         if (!push_deferred_smb_message(mid, request_time, timeout,
 746                                        (char *)state, sizeof(*state))) {
 747                 exit_server("push_deferred_smb_message failed\n");
 748         }
 749         add_deferred_open(lck, mid, request_time, state->dev, state->inode);
 750
 751         /*
 752          * Push the MID of this packet on the signing queue.
 753          * We only do this once, the first time we push the packet
 754          * onto the deferred open queue, as this has a side effect
 755          * of incrementing the response sequence number.
 756          */
 757
 758         srv_defer_sign_response(mid);
 759 }
 760
 761 /****************************************************************************
 762  Set a kernel flock on a file for NFS interoperability.
 763  This requires a patch to Linux.
 764 ****************************************************************************/
 765
 766 static void kernel_flock(files_struct *fsp, uint32 share_mode)
 767 {
 768 #if HAVE_KERNEL_SHARE_MODES
 769         int kernel_mode = 0;
 770         if (share_mode == FILE_SHARE_WRITE) {
 771                 kernel_mode = LOCK_MAND|LOCK_WRITE;
 772         } else if (share_mode == FILE_SHARE_READ) {
 773                 kernel_mode = LOCK_MAND|LOCK_READ;
 774         } else if (share_mode == FILE_SHARE_NONE) {
 775                 kernel_mode = LOCK_MAND;
 776         }
 777         if (kernel_mode) {
 778                 flock(fsp->fh->fd, kernel_mode);
 779         }
 780 #endif
 781         ;
 782 }
 783
 784 /****************************************************************************
 785  On overwrite open ensure that the attributes match.
 786 ****************************************************************************/
 787
 788 static BOOL open_match_attributes(connection_struct *conn,
 789                                 const char *path,
 790                                 uint32 old_dos_attr,
 791                                 uint32 new_dos_attr,
 792                                 mode_t existing_unx_mode,
 793                                 mode_t new_unx_mode,
 794                                 mode_t *returned_unx_mode)
 795 {
 796         uint32 noarch_old_dos_attr, noarch_new_dos_attr;
 797
 798         noarch_old_dos_attr = (old_dos_attr & ~FILE_ATTRIBUTE_ARCHIVE);
 799         noarch_new_dos_attr = (new_dos_attr & ~FILE_ATTRIBUTE_ARCHIVE);
 800
 801         if((noarch_old_dos_attr == 0 && noarch_new_dos_attr != 0) ||
 802            (noarch_old_dos_attr != 0 && ((noarch_old_dos_attr & noarch_new_dos_attr) == noarch_old_dos_attr))) {
 803                 *returned_unx_mode = new_unx_mode;
 804         } else {
 805                 *returned_unx_mode = (mode_t)0;
 806         }
 807
 808         DEBUG(10,("open_match_attributes: file %s old_dos_attr = 0x%x, "
 809                   "existing_unx_mode = 0%o, new_dos_attr = 0x%x "
 810                   "returned_unx_mode = 0%o\n",
 811                   path,
 812                   (unsigned int)old_dos_attr,
 813                   (unsigned int)existing_unx_mode,
 814                   (unsigned int)new_dos_attr,
 815                   (unsigned int)*returned_unx_mode ));
 816
 817         /* If we're mapping SYSTEM and HIDDEN ensure they match. */
 818         if (lp_map_system(SNUM(conn)) || lp_store_dos_attributes(SNUM(conn))) {
 819                 if ((old_dos_attr & FILE_ATTRIBUTE_SYSTEM) &&
 820                     !(new_dos_attr & FILE_ATTRIBUTE_SYSTEM)) {
 821                         return False;
 822                 }
 823         }
 824         if (lp_map_hidden(SNUM(conn)) || lp_store_dos_attributes(SNUM(conn))) {
 825                 if ((old_dos_attr & FILE_ATTRIBUTE_HIDDEN) &&
 826                     !(new_dos_attr & FILE_ATTRIBUTE_HIDDEN)) {
 827                         return False;
 828                 }
 829         }
 830         return True;
 831 }
 832
 833 /****************************************************************************
 834  Special FCB or DOS processing in the case of a sharing violation.
 835  Try and find a duplicated file handle.
 836 ****************************************************************************/
 837
 838 static files_struct *fcb_or_dos_open(connection_struct *conn,
 839                                      const char *fname, SMB_DEV_T dev,
 840                                      SMB_INO_T inode,
 841                                      uint32 access_mask,
 842                                      uint32 share_access,
 843                                      uint32 create_options)
 844 {
 845         files_struct *fsp;
 846         files_struct *dup_fsp;
 847
 848         DEBUG(5,("fcb_or_dos_open: attempting old open semantics for "
 849                  "file %s.\n", fname ));
 850
 851         for(fsp = file_find_di_first(dev, inode); fsp;
 852             fsp = file_find_di_next(fsp)) {
 853
 854                 DEBUG(10,("fcb_or_dos_open: checking file %s, fd = %d, "
 855                           "vuid = %u, file_pid = %u, private_options = 0x%x "
 856                           "access_mask = 0x%x\n", fsp->fsp_name,
 857                           fsp->fh->fd, (unsigned int)fsp->vuid,
 858                           (unsigned int)fsp->file_pid,
 859                           (unsigned int)fsp->fh->private_options,
 860                           (unsigned int)fsp->access_mask ));
 861
 862                 if (fsp->fh->fd != -1 &&
 863                     fsp->vuid == current_user.vuid &&
 864                     fsp->file_pid == global_smbpid &&
 865                     (fsp->fh->private_options & (NTCREATEX_OPTIONS_PRIVATE_DENY_DOS |
 866                                                  NTCREATEX_OPTIONS_PRIVATE_DENY_FCB)) &&
 867                     (fsp->access_mask & FILE_WRITE_DATA) &&
 868                     strequal(fsp->fsp_name, fname)) {
 869                         DEBUG(10,("fcb_or_dos_open: file match\n"));
 870                         break;
 871                 }
 872         }
 873
 874         if (!fsp) {
 875                 return NULL;
 876         }
 877
 878         /* quite an insane set of semantics ... */
 879         if (is_executable(fname) &&
 880             (fsp->fh->private_options & NTCREATEX_OPTIONS_PRIVATE_DENY_DOS)) {
 881                 DEBUG(10,("fcb_or_dos_open: file fail due to is_executable.\n"));
 882                 return NULL;
 883         }
 884
 885         /* We need to duplicate this fsp. */
 886         dup_fsp = dup_file_fsp(fsp, access_mask, share_access, create_options);
 887         if (!dup_fsp) {
 888                 return NULL;
 889         }
 890
 891         return dup_fsp;
 892 }
 893
 894 /****************************************************************************
 895  Open a file with a share mode - old openX method - map into NTCreate.
 896 ****************************************************************************/
 897
 898 BOOL map_open_params_to_ntcreate(const char *fname, int deny_mode, int open_func,
 899                                 uint32 *paccess_mask,
 900                                 uint32 *pshare_mode,
 901                                 uint32 *pcreate_disposition,
 902                                 uint32 *pcreate_options)
 903 {
 904         uint32 access_mask;
 905         uint32 share_mode;
 906         uint32 create_disposition;
 907         uint32 create_options = 0;
 908
 909         DEBUG(10,("map_open_params_to_ntcreate: fname = %s, deny_mode = 0x%x, "
 910                   "open_func = 0x%x\n",
 911                   fname, (unsigned int)deny_mode, (unsigned int)open_func ));
 912
 913         /* Create the NT compatible access_mask. */
 914         switch (GET_OPENX_MODE(deny_mode)) {
 915                 case DOS_OPEN_EXEC: /* Implies read-only - used to be FILE_READ_DATA */
 916                 case DOS_OPEN_RDONLY:
 917                         access_mask = FILE_GENERIC_READ;
 918                         break;
 919                 case DOS_OPEN_WRONLY:
 920                         access_mask = FILE_GENERIC_WRITE;
 921                         break;
 922                 case DOS_OPEN_RDWR:
 923                 case DOS_OPEN_FCB:
 924                         access_mask = FILE_GENERIC_READ|FILE_GENERIC_WRITE;
 925                         break;
 926                 default:
 927                         DEBUG(10,("map_open_params_to_ntcreate: bad open mode = 0x%x\n",
 928                                   (unsigned int)GET_OPENX_MODE(deny_mode)));
 929                         return False;
 930         }
 931
 932         /* Create the NT compatible create_disposition. */
 933         switch (open_func) {
 934                 case OPENX_FILE_EXISTS_FAIL|OPENX_FILE_CREATE_IF_NOT_EXIST:
 935                         create_disposition = FILE_CREATE;
 936                         break;
 937
 938                 case OPENX_FILE_EXISTS_OPEN:
 939                         create_disposition = FILE_OPEN;
 940                         break;
 941
 942                 case OPENX_FILE_EXISTS_OPEN|OPENX_FILE_CREATE_IF_NOT_EXIST:
 943                         create_disposition = FILE_OPEN_IF;
 944                         break;
 945
 946                 case OPENX_FILE_EXISTS_TRUNCATE:
 947                         create_disposition = FILE_OVERWRITE;
 948                         break;
 949
 950                 case OPENX_FILE_EXISTS_TRUNCATE|OPENX_FILE_CREATE_IF_NOT_EXIST:
 951                         create_disposition = FILE_OVERWRITE_IF;
 952                         break;
 953
 954                 default:
 955                         /* From samba4 - to be confirmed. */
 956                         if (GET_OPENX_MODE(deny_mode) == DOS_OPEN_EXEC) {
 957                                 create_disposition = FILE_CREATE;
 958                                 break;
 959                         }
 960                         DEBUG(10,("map_open_params_to_ntcreate: bad "
 961                                   "open_func 0x%x\n", (unsigned int)open_func));
 962                         return False;
 963         }
 964
 965         /* Create the NT compatible share modes. */
 966         switch (GET_DENY_MODE(deny_mode)) {
 967                 case DENY_ALL:
 968                         share_mode = FILE_SHARE_NONE;
 969                         break;
 970
 971                 case DENY_WRITE:
 972                         share_mode = FILE_SHARE_READ;
 973                         break;
 974
 975                 case DENY_READ:
 976                         share_mode = FILE_SHARE_WRITE;
 977                         break;
 978
 979                 case DENY_NONE:
 980                         share_mode = FILE_SHARE_READ|FILE_SHARE_WRITE;
 981                         break;
 982
 983                 case DENY_DOS:
 984                         create_options |= NTCREATEX_OPTIONS_PRIVATE_DENY_DOS;
 985                         if (is_executable(fname)) {
 986                                 share_mode = FILE_SHARE_READ|FILE_SHARE_WRITE;
 987                         } else {
 988                                 if (GET_OPENX_MODE(deny_mode) == DOS_OPEN_RDONLY) {
 989                                         share_mode = FILE_SHARE_READ;
 990                                 } else {
 991                                         share_mode = FILE_SHARE_NONE;
 992                                 }
 993                         }
 994                         break;
 995
 996                 case DENY_FCB:
 997                         create_options |= NTCREATEX_OPTIONS_PRIVATE_DENY_FCB;
 998                         share_mode = FILE_SHARE_NONE;
 999                         break;
1000
1001                 default:
1002                         DEBUG(10,("map_open_params_to_ntcreate: bad deny_mode 0x%x\n",
1003                                 (unsigned int)GET_DENY_MODE(deny_mode) ));
1004                         return False;
1005         }
1006
1007         DEBUG(10,("map_open_params_to_ntcreate: file %s, access_mask = 0x%x, "
1008                   "share_mode = 0x%x, create_disposition = 0x%x, "
1009                   "create_options = 0x%x\n",
1010                   fname,
1011                   (unsigned int)access_mask,
1012                   (unsigned int)share_mode,
1013                   (unsigned int)create_disposition,
1014                   (unsigned int)create_options ));
1015
1016         if (paccess_mask) {
1017                 *paccess_mask = access_mask;
1018         }
1019         if (pshare_mode) {
1020                 *pshare_mode = share_mode;
1021         }
1022         if (pcreate_disposition) {
1023                 *pcreate_disposition = create_disposition;
1024         }
1025         if (pcreate_options) {
1026                 *pcreate_options = create_options;
1027         }
1028
1029         return True;
1030
1031 }
1032
1033 /* Map generic permissions to file object specific permissions */
1034
1035 struct generic_mapping file_generic_mapping = {
1036         FILE_GENERIC_READ,
1037         FILE_GENERIC_WRITE,
1038         FILE_GENERIC_EXECUTE,
1039         FILE_GENERIC_ALL
1040 };
1041
1042 /****************************************************************************
1043  Open a file with a share mode.
1044 ****************************************************************************/
1045
1046 files_struct *open_file_ntcreate(connection_struct *conn,
1047                                  const char *fname,
1048                                  SMB_STRUCT_STAT *psbuf,
1049                                  uint32 access_mask,            /* access bits (FILE_READ_DATA etc.) */
1050                                  uint32 share_access,           /* share constants (FILE_SHARE_READ etc). */
1051                                  uint32 create_disposition,     /* FILE_OPEN_IF etc. */
1052                                  uint32 create_options,         /* options such as delete on close. */
1053                                  uint32 new_dos_attributes,     /* attributes used for new file. */
1054                                  int oplock_request,            /* internal Samba oplock codes. */
1055                                                                 /* Information (FILE_EXISTS etc.) */
1056                                  int *pinfo)
1057 {
1058         int flags=0;
1059         int flags2=0;
1060         BOOL file_existed = VALID_STAT(*psbuf);
1061         BOOL def_acl = False;
1062         BOOL internal_only_open = False;
1063         SMB_DEV_T dev = 0;
1064         SMB_INO_T inode = 0;
1065         BOOL fsp_open = False;
1066         files_struct *fsp = NULL;
1067         mode_t new_unx_mode = (mode_t)0;
1068         mode_t unx_mode = (mode_t)0;
1069         int info;
1070         uint32 existing_dos_attributes = 0;
1071         struct pending_message_list *pml = NULL;
1072         uint16 mid = get_current_mid();
1073         BOOL delayed_for_oplocks = False;
1074         struct timeval request_time = timeval_zero();
1075         struct share_mode_lock *lck = NULL;
1076         NTSTATUS status;
1077
1078         if (conn->printer) {
1079                 /*
1080                  * Printers are handled completely differently.
1081                  * Most of the passed parameters are ignored.
1082                  */
1083
1084                 if (pinfo) {
1085                         *pinfo = FILE_WAS_CREATED;
1086                 }
1087
1088                 DEBUG(10, ("open_file_ntcreate: printer open fname=%s\n", fname));
1089
1090                 return print_fsp_open(conn, fname);
1091         }
1092
1093         /* We add aARCH to this as this mode is only used if the file is
1094          * created new. */
1095         unx_mode = unix_mode(conn, new_dos_attributes | aARCH,fname, True);
1096
1097         DEBUG(10, ("open_file_ntcreate: fname=%s, dos_attrs=0x%x "
1098                    "access_mask=0x%x share_access=0x%x "
1099                    "create_disposition = 0x%x create_options=0x%x "
1100                    "unix mode=0%o oplock_request=%d\n",
1101                    fname, new_dos_attributes, access_mask, share_access,
1102                    create_disposition, create_options, unx_mode,
1103                    oplock_request));
1104
1105         if (oplock_request == INTERNAL_OPEN_ONLY) {
1106                 internal_only_open = True;
1107                 oplock_request = 0;
1108         }
1109
1110         if ((pml = get_open_deferred_message(mid)) != NULL) {
1111                 struct deferred_open_record *state =
1112                         (struct deferred_open_record *)pml->private_data.data;
1113
1114                 request_time = pml->request_time;
1115                 delayed_for_oplocks = state->delayed_for_oplocks;
1116
1117                 /* There could be a race condition where the dev/inode pair
1118                    has changed since we deferred the message. If so, just
1119                    remove the deferred open entry and return sharing
1120                    violation. */
1121
1122                 /* If the timeout value is non-zero, we need to just return
1123                    sharing violation. Don't retry the open as we were not
1124                    notified of a close and we don't want to trigger another
1125                    spurious oplock break. */
1126
1127                 /* Now remove the deferred open entry under lock. */
1128                 lck = get_share_mode_lock(NULL, state->dev, state->inode,
1129                                           fname);
1130                 if (lck == NULL) {
1131                         DEBUG(0, ("could not get share mode lock\n"));
1132                 } else {
1133                         del_deferred_open_entry(lck, mid);
1134                         talloc_destroy(lck);
1135                 }
1136
1137                 /* Ensure we don't reprocess this message. */
1138                 remove_deferred_open_smb_message(mid);
1139         }
1140
1141         if (!check_name(fname,conn)) {
1142                 return NULL;
1143         }
1144
1145         new_dos_attributes &= SAMBA_ATTRIBUTES_MASK;
1146         if (file_existed) {
1147                 existing_dos_attributes = dos_mode(conn, fname, psbuf);
1148         }
1149
1150         /* ignore any oplock requests if oplocks are disabled */
1151         if (!lp_oplocks(SNUM(conn)) || global_client_failed_oplock_break ||
1152             IS_VETO_OPLOCK_PATH(conn, fname)) {
1153                 oplock_request = 0;
1154         }
1155
1156         /* this is for OS/2 long file names - say we don't support them */
1157         if (!lp_posix_pathnames() && strstr(fname,".+,;=[].")) {
1158                 /* OS/2 Workplace shell fix may be main code stream in a later
1159                  * release. */
1160                 set_saved_error_triple(ERRDOS, ERRcannotopen,
1161                                        NT_STATUS_OBJECT_NAME_NOT_FOUND);
1162                 DEBUG(5,("open_file_ntcreate: OS/2 long filenames are not "
1163                          "supported.\n"));
1164                 return NULL;
1165         }
1166
1167         switch( create_disposition ) {
1168                 /*
1169                  * Currently we're using FILE_SUPERSEDE as the same as
1170                  * FILE_OVERWRITE_IF but they really are
1171                  * different. FILE_SUPERSEDE deletes an existing file
1172                  * (requiring delete access) then recreates it.
1173                  */
1174                 case FILE_SUPERSEDE:
1175                         /* If file exists replace/overwrite. If file doesn't
1176                          * exist create. */
1177                         flags2 |= (O_CREAT | O_TRUNC);
1178                         break;
1179
1180                 case FILE_OVERWRITE_IF:
1181                         /* If file exists replace/overwrite. If file doesn't
1182                          * exist create. */
1183                         flags2 |= (O_CREAT | O_TRUNC);
1184                         break;
1185
1186                 case FILE_OPEN:
1187                         /* If file exists open. If file doesn't exist error. */
1188                         if (!file_existed) {
1189                                 DEBUG(5,("open_file_ntcreate: FILE_OPEN "
1190                                          "requested for file %s and file "
1191                                          "doesn't exist.\n", fname ));
1192                                 set_saved_ntstatus(NT_STATUS_OBJECT_NAME_NOT_FOUND);
1193                                 errno = ENOENT;
1194                                 return NULL;
1195                         }
1196                         break;
1197
1198                 case FILE_OVERWRITE:
1199                         /* If file exists overwrite. If file doesn't exist
1200                          * error. */
1201                         if (!file_existed) {
1202                                 DEBUG(5,("open_file_ntcreate: FILE_OVERWRITE "
1203                                          "requested for file %s and file "
1204                                          "doesn't exist.\n", fname ));
1205                                 set_saved_ntstatus(NT_STATUS_OBJECT_NAME_NOT_FOUND);
1206                                 errno = ENOENT;
1207                                 return NULL;
1208                         }
1209                         flags2 |= O_TRUNC;
1210                         break;
1211
1212                 case FILE_CREATE:
1213                         /* If file exists error. If file doesn't exist
1214                          * create. */
1215                         if (file_existed) {
1216                                 DEBUG(5,("open_file_ntcreate: FILE_CREATE "
1217                                          "requested for file %s and file "
1218                                          "already exists.\n", fname ));
1219                                 if (S_ISDIR(psbuf->st_mode)) {
1220                                         errno = EISDIR;
1221                                 } else {
1222                                         errno = EEXIST;
1223                                 }
1224                                 return NULL;
1225                         }
1226                         flags2 |= (O_CREAT|O_EXCL);
1227                         break;
1228
1229                 case FILE_OPEN_IF:
1230                         /* If file exists open. If file doesn't exist
1231                          * create. */
1232                         flags2 |= O_CREAT;
1233                         break;
1234
1235                 default:
1236                         set_saved_ntstatus(NT_STATUS_INVALID_PARAMETER);
1237                         return NULL;
1238         }
1239
1240         /* We only care about matching attributes on file exists and
1241          * overwrite. */
1242
1243         if (file_existed && ((create_disposition == FILE_OVERWRITE) ||
1244                              (create_disposition == FILE_OVERWRITE_IF))) {
1245                 if (!open_match_attributes(conn, fname,
1246                                            existing_dos_attributes,
1247                                            new_dos_attributes, psbuf->st_mode,
1248                                            unx_mode, &new_unx_mode)) {
1249                         DEBUG(5,("open_file_ntcreate: attributes missmatch "
1250                                  "for file %s (%x %x) (0%o, 0%o)\n",
1251                                  fname, existing_dos_attributes,
1252                                  new_dos_attributes,
1253                                  (unsigned int)psbuf->st_mode,
1254                                  (unsigned int)unx_mode ));
1255                         errno = EACCES;
1256                         return NULL;
1257                 }
1258         }
1259
1260         /* This is a nasty hack - must fix... JRA. */
1261         if (access_mask == MAXIMUM_ALLOWED_ACCESS) {
1262                 access_mask = FILE_GENERIC_ALL;
1263         }
1264
1265         /*
1266          * Convert GENERIC bits to specific bits.
1267          */
1268
1269         se_map_generic(&access_mask, &file_generic_mapping);
1270
1271         DEBUG(10, ("open_file_ntcreate: fname=%s, after mapping "
1272                    "access_mask=0x%x\n", fname, access_mask ));
1273
1274         /*
1275          * Note that we ignore the append flag as append does not
1276          * mean the same thing under DOS and Unix.
1277          */
1278
1279         if (access_mask & (FILE_WRITE_DATA | FILE_APPEND_DATA)) {
1280                 flags = O_RDWR;
1281         } else {
1282                 flags = O_RDONLY;
1283         }
1284
1285         /*
1286          * Currently we only look at FILE_WRITE_THROUGH for create options.
1287          */
1288
1289 #if defined(O_SYNC)
1290         if (create_options & FILE_WRITE_THROUGH) {
1291                 flags2 |= O_SYNC;
1292         }
1293 #endif /* O_SYNC */
1294
1295         if (!CAN_WRITE(conn)) {
1296                 /*
1297                  * We should really return a permission denied error if either
1298                  * O_CREAT or O_TRUNC are set, but for compatibility with
1299                  * older versions of Samba we just AND them out.
1300                  */
1301                 flags2 &= ~(O_CREAT|O_TRUNC);
1302         }
1303
1304         /*
1305          * Ensure we can't write on a read-only share or file.
1306          */
1307
1308         if (flags != O_RDONLY && file_existed &&
1309             (!CAN_WRITE(conn) || IS_DOS_READONLY(existing_dos_attributes))) {
1310                 DEBUG(5,("open_file_ntcreate: write access requested for "
1311                          "file %s on read only %s\n",
1312                          fname, !CAN_WRITE(conn) ? "share" : "file" ));
1313                 set_saved_ntstatus(NT_STATUS_ACCESS_DENIED);
1314                 errno = EACCES;
1315                 return NULL;
1316         }
1317
1318         fsp = file_new(conn);
1319         if(!fsp) {
1320                 return NULL;
1321         }
1322
1323         fsp->dev = psbuf->st_dev;
1324         fsp->inode = psbuf->st_ino;
1325         fsp->share_access = share_access;
1326         fsp->fh->private_options = create_options;
1327         fsp->access_mask = access_mask;
1328         fsp->oplock_type = oplock_request;
1329
1330         if (timeval_is_zero(&request_time)) {
1331                 request_time = fsp->open_time;
1332         }
1333
1334         if (file_existed) {
1335
1336                 dev = psbuf->st_dev;
1337                 inode = psbuf->st_ino;
1338
1339                 lck = get_share_mode_lock(NULL, dev, inode, fname);
1340
1341                 if (lck == NULL) {
1342                         DEBUG(0, ("Could not get share mode lock\n"));
1343                         set_saved_ntstatus(NT_STATUS_SHARING_VIOLATION);
1344                         return NULL;
1345                 }
1346
1347                 if (delay_for_oplocks(lck, fsp)) {
1348                         struct deferred_open_record state;
1349                         struct timeval timeout;
1350
1351                         if (delayed_for_oplocks) {
1352                                 DEBUG(0, ("Trying to delay for oplocks "
1353                                           "twice\n"));
1354                                 exit_server("exiting");
1355                         }
1356
1357                         timeout = timeval_set(OPLOCK_BREAK_TIMEOUT*2, 0);
1358
1359                         /* Normally the smbd we asked should respond within
1360                          * OPLOCK_BREAK_TIMEOUT seconds regardless of whether
1361                          * the client did, give twice the timeout as a safety
1362                          * measure here in case the other smbd is stuck
1363                          * somewhere else. */
1364
1365                         state.delayed_for_oplocks = True;
1366                         state.dev = dev;
1367                         state.inode = inode;
1368
1369                         if (!request_timed_out(request_time, timeout)) {
1370                                 defer_open(lck, request_time, timeout,
1371                                            &state);
1372                         }
1373
1374                         talloc_free(lck);
1375                         return NULL;
1376                 }
1377
1378                 status = open_mode_check(conn, fname, lck,
1379                                          access_mask, share_access,
1380                                          create_options, &file_existed);
1381
1382                 if (NT_STATUS_EQUAL(status, NT_STATUS_DELETE_PENDING)) {
1383                         /* DELETE_PENDING is not deferred for a second */
1384                         set_saved_ntstatus(status);
1385                         talloc_free(lck);
1386                         file_free(fsp);
1387                         return NULL;
1388                 }
1389
1390                 if (!NT_STATUS_IS_OK(status)) {
1391
1392                         SMB_ASSERT(NT_STATUS_EQUAL(status, NT_STATUS_SHARING_VIOLATION));
1393
1394                         /* Check if this can be done with the deny_dos and fcb
1395                          * calls. */
1396                         if (create_options &
1397                             (NTCREATEX_OPTIONS_PRIVATE_DENY_DOS|
1398                              NTCREATEX_OPTIONS_PRIVATE_DENY_FCB)) {
1399                                 files_struct *fsp_dup;
1400                                 fsp_dup = fcb_or_dos_open(conn, fname, dev,
1401                                                           inode, access_mask,
1402                                                           share_access,
1403                                                           create_options);
1404
1405                                 if (fsp_dup) {
1406                                         talloc_free(lck);
1407                                         file_free(fsp);
1408                                         if (pinfo) {
1409                                                 *pinfo = FILE_WAS_OPENED;
1410                                         }
1411                                         conn->num_files_open++;
1412                                         return fsp_dup;
1413                                 }
1414                         }
1415
1416                         /*
1417                          * This next line is a subtlety we need for
1418                          * MS-Access. If a file open will fail due to share
1419                          * permissions and also for security (access) reasons,
1420                          * we need to return the access failed error, not the
1421                          * share error. This means we must attempt to open the
1422                          * file anyway in order to get the UNIX access error -
1423                          * even if we're going to fail the open for share
1424                          * reasons. This is bad, as we're burning another fd
1425                          * if there are existing locks but there's nothing
1426                          * else we can do. We also ensure we're not going to
1427                          * create or tuncate the file as we only want an
1428                          * access decision at this stage. JRA.
1429                          */
1430                         errno = 0;
1431                         fsp_open = open_file(fsp,conn,fname,psbuf,
1432                                              flags|(flags2&~(O_TRUNC|O_CREAT)),
1433                                              unx_mode,access_mask);
1434
1435                         DEBUG(4,("open_file_ntcreate : share_mode deny - "
1436                                  "calling open_file with flags=0x%X "
1437                                  "flags2=0x%X mode=0%o returned %d\n",
1438                                  flags, (flags2&~(O_TRUNC|O_CREAT)),
1439                                  (unsigned int)unx_mode, (int)fsp_open ));
1440
1441                         if (!fsp_open && errno) {
1442                                 /* Default error. */
1443                                 set_saved_ntstatus(NT_STATUS_ACCESS_DENIED);
1444                         }
1445
1446                         /*
1447                          * If we're returning a share violation, ensure we
1448                          * cope with the braindead 1 second delay.
1449                          */
1450
1451                         if (!internal_only_open &&
1452                             lp_defer_sharing_violations()) {
1453                                 struct timeval timeout;
1454                                 struct deferred_open_record state;
1455
1456                                 timeout = timeval_set(0, SHARING_VIOLATION_USEC_WAIT);
1457
1458                                 state.delayed_for_oplocks = False;
1459                                 state.dev = dev;
1460                                 state.inode = inode;
1461
1462                                 if (!request_timed_out(request_time,
1463                                                        timeout)) {
1464                                         defer_open(lck, request_time, timeout,
1465                                                    &state);
1466                                 }
1467                         }
1468
1469                         talloc_free(lck);
1470                         if (fsp_open) {
1471                                 fd_close(conn, fsp);
1472                                 /*
1473                                  * We have detected a sharing violation here
1474                                  * so return the correct error code
1475                                  */
1476                                 set_saved_ntstatus(NT_STATUS_SHARING_VIOLATION);
1477                         }
1478                         file_free(fsp);
1479                         return NULL;
1480                 }
1481
1482                 /*
1483                  * We exit this block with the share entry *locked*.....
1484                  */
1485         }
1486
1487         SMB_ASSERT(!file_existed || (lck != NULL));
1488
1489         /*
1490          * Ensure we pay attention to default ACLs on directories if required.
1491          */
1492
1493         if ((flags2 & O_CREAT) && lp_inherit_acls(SNUM(conn)) &&
1494             (def_acl = directory_has_default_acl(conn,
1495                                                  parent_dirname(fname)))) {
1496                 unx_mode = 0777;
1497         }
1498
1499         DEBUG(4,("calling open_file with flags=0x%X flags2=0x%X mode=0%o\n",
1500                  (unsigned int)flags, (unsigned int)flags2,
1501                  (unsigned int)unx_mode));
1502
1503         /*
1504          * open_file strips any O_TRUNC flags itself.
1505          */
1506
1507         fsp_open = open_file(fsp,conn,fname,psbuf,flags|flags2,unx_mode,
1508                              access_mask);
1509
1510         if (!fsp_open) {
1511                 if (lck != NULL) {
1512                         talloc_free(lck);
1513                 }
1514                 file_free(fsp);
1515                 return NULL;
1516         }
1517
1518         if (!file_existed) {
1519
1520                 /*
1521                  * Deal with the race condition where two smbd's detect the
1522                  * file doesn't exist and do the create at the same time. One
1523                  * of them will win and set a share mode, the other (ie. this
1524                  * one) should check if the requested share mode for this
1525                  * create is allowed.
1526                  */
1527
1528                 /*
1529                  * Now the file exists and fsp is successfully opened,
1530                  * fsp->dev and fsp->inode are valid and should replace the
1531                  * dev=0,inode=0 from a non existent file. Spotted by
1532                  * Nadav Danieli <nadavd@exanet.com>. JRA.
1533                  */
1534
1535                 dev = fsp->dev;
1536                 inode = fsp->inode;
1537
1538                 lck = get_share_mode_lock(NULL, dev, inode, fname);
1539
1540                 if (lck == NULL) {
1541                         DEBUG(0, ("Coult not get share mode lock\n"));
1542                         fd_close(conn, fsp);
1543                         file_free(fsp);
1544                         set_saved_ntstatus(NT_STATUS_SHARING_VIOLATION);
1545                         return NULL;
1546                 }
1547
1548                 status = open_mode_check(conn, fname, lck,
1549                                          access_mask, share_access,
1550                                          create_options, &file_existed);
1551
1552                 if (!NT_STATUS_IS_OK(status)) {
1553                         struct deferred_open_record state;
1554
1555                         fd_close(conn, fsp);
1556                         file_free(fsp);
1557
1558                         state.delayed_for_oplocks = False;
1559                         state.dev = dev;
1560                         state.inode = inode;
1561
1562                         /* Do it all over again immediately. In the second
1563                          * round we will find that the file existed and handle
1564                          * the DELETE_PENDING and FCB cases correctly. No need
1565                          * to duplicate the code here. Essentially this is a
1566                          * "goto top of this function", but don't tell
1567                          * anybody... */
1568
1569                         defer_open(lck, request_time, timeval_zero(),
1570                                    &state);
1571                         talloc_free(lck);
1572                         return NULL;
1573                 }
1574
1575                 /*
1576                  * We exit this block with the share entry *locked*.....
1577                  */
1578         }
1579
1580         SMB_ASSERT(lck != NULL);
1581
1582         /* note that we ignore failure for the following. It is
1583            basically a hack for NFS, and NFS will never set one of
1584            these only read them. Nobody but Samba can ever set a deny
1585            mode and we have already checked our more authoritative
1586            locking database for permission to set this deny mode. If
1587            the kernel refuses the operations then the kernel is wrong */
1588
1589         kernel_flock(fsp, share_access);
1590
1591         /*
1592          * At this point onwards, we can guarentee that the share entry
1593          * is locked, whether we created the file or not, and that the
1594          * deny mode is compatible with all current opens.
1595          */
1596
1597         /*
1598          * If requested, truncate the file.
1599          */
1600
1601         if (flags2&O_TRUNC) {
1602                 /*
1603                  * We are modifing the file after open - update the stat
1604                  * struct..
1605                  */
1606                 if ((SMB_VFS_FTRUNCATE(fsp,fsp->fh->fd,0) == -1) ||
1607                     (SMB_VFS_FSTAT(fsp,fsp->fh->fd,psbuf)==-1)) {
1608                         talloc_free(lck);
1609                         fd_close(conn,fsp);
1610                         file_free(fsp);
1611                         return NULL;
1612                 }
1613         }
1614
1615         /* Record the options we were opened with. */
1616         fsp->share_access = share_access;
1617         fsp->fh->private_options = create_options;
1618         fsp->access_mask = access_mask;
1619
1620         if (file_existed) {
1621                 if (!(flags2 & O_TRUNC)) {
1622                         info = FILE_WAS_OPENED;
1623                 } else {
1624                         info = FILE_WAS_OVERWRITTEN;
1625                 }
1626         } else {
1627                 info = FILE_WAS_CREATED;
1628                 /* Change the owner if required. */
1629                 if (lp_inherit_owner(SNUM(conn))) {
1630                         change_owner_to_parent(conn, fsp, fsp->fsp_name,
1631                                                psbuf);
1632                 }
1633         }
1634
1635         if (pinfo) {
1636                 *pinfo = info;
1637         }
1638
1639         /*
1640          * Setup the oplock info in both the shared memory and
1641          * file structs.
1642          */
1643
1644         if ((fsp->oplock_type != NO_OPLOCK) &&
1645             (fsp->oplock_type != FAKE_LEVEL_II_OPLOCK)) {
1646                 if (!set_file_oplock(fsp, fsp->oplock_type)) {
1647                         /* Could not get the kernel oplock */
1648                         fsp->oplock_type = NO_OPLOCK;
1649                 }
1650         }
1651         set_share_mode(lck, fsp, 0, fsp->oplock_type);
1652
1653         if (create_options & FILE_DELETE_ON_CLOSE) {
1654                 uint32 dosattr= existing_dos_attributes;
1655                 NTSTATUS result;
1656
1657                 if (info == FILE_WAS_OVERWRITTEN || info == FILE_WAS_CREATED ||
1658                                 info == FILE_WAS_SUPERSEDED) {
1659                         dosattr = new_dos_attributes;
1660                 }
1661
1662                 result = can_set_delete_on_close(fsp, True, dosattr);
1663
1664                 if (!NT_STATUS_IS_OK(result)) {
1665                         /* Remember to delete the mode we just added. */
1666                         del_share_mode(lck, fsp);
1667                         talloc_free(lck);
1668                         fd_close(conn,fsp);
1669                         file_free(fsp);
1670                         set_saved_ntstatus(result);
1671                         return NULL;
1672                 }
1673                 lck->delete_on_close = True;
1674                 lck->modified = True;
1675         }
1676
1677         if (info == FILE_WAS_OVERWRITTEN || info == FILE_WAS_CREATED ||
1678                                 info == FILE_WAS_SUPERSEDED) {
1679                 /* Files should be initially set as archive */
1680                 if (lp_map_archive(SNUM(conn)) ||
1681                     lp_store_dos_attributes(SNUM(conn))) {
1682                         file_set_dosmode(conn, fname,
1683                                          new_dos_attributes | aARCH, NULL,
1684                                          True);
1685                 }
1686         }
1687
1688         /*
1689          * Take care of inherited ACLs on created files - if default ACL not
1690          * selected.
1691          */
1692
1693         if (!file_existed && !def_acl) {
1694
1695                 int saved_errno = errno; /* We might get ENOSYS in the next
1696                                           * call.. */
1697
1698                 if (SMB_VFS_FCHMOD_ACL(fsp, fsp->fh->fd, unx_mode) == -1
1699                     && errno == ENOSYS) {
1700                         errno = saved_errno; /* Ignore ENOSYS */
1701                 }
1702
1703         } else if (new_unx_mode) {
1704
1705                 int ret = -1;
1706
1707                 /* Attributes need changing. File already existed. */
1708
1709                 {
1710                         int saved_errno = errno; /* We might get ENOSYS in the
1711                                                   * next call.. */
1712                         ret = SMB_VFS_FCHMOD_ACL(fsp, fsp->fh->fd,
1713                                                  new_unx_mode);
1714
1715                         if (ret == -1 && errno == ENOSYS) {
1716                                 errno = saved_errno; /* Ignore ENOSYS */
1717                         } else {
1718                                 DEBUG(5, ("open_file_shared: reset "
1719                                           "attributes of file %s to 0%o\n",
1720                                         fname, (unsigned int)new_unx_mode));
1721                                 ret = 0; /* Don't do the fchmod below. */
1722                         }
1723                 }
1724
1725                 if ((ret == -1) &&
1726                     (SMB_VFS_FCHMOD(fsp, fsp->fh->fd, new_unx_mode) == -1))
1727                         DEBUG(5, ("open_file_shared: failed to reset "
1728                                   "attributes of file %s to 0%o\n",
1729                                 fname, (unsigned int)new_unx_mode));
1730         }
1731
1732         /* If this is a successful open, we must remove any deferred open
1733          * records. */
1734         del_deferred_open_entry(lck, mid);
1735         talloc_free(lck);
1736
1737         conn->num_files_open++;
1738
1739         return fsp;
1740 }
1741
1742 /****************************************************************************
1743  Open a file for for write to ensure that we can fchmod it.
1744 ****************************************************************************/
1745
1746 files_struct *open_file_fchmod(connection_struct *conn, const char *fname,
1747                                SMB_STRUCT_STAT *psbuf)
1748 {
1749         files_struct *fsp = NULL;
1750         BOOL fsp_open;
1751
1752         if (!VALID_STAT(*psbuf)) {
1753                 return NULL;
1754         }
1755
1756         fsp = file_new(conn);
1757         if(!fsp) {
1758                 return NULL;
1759         }
1760
1761         /* note! we must use a non-zero desired access or we don't get
1762            a real file descriptor. Oh what a twisted web we weave. */
1763         fsp_open = open_file(fsp,conn,fname,psbuf,O_WRONLY,0,FILE_WRITE_DATA);
1764
1765         /*
1766          * This is not a user visible file open.
1767          * Don't set a share mode and don't increment
1768          * the conn->num_files_open.
1769          */
1770
1771         if (!fsp_open) {
1772                 file_free(fsp);
1773                 return NULL;
1774         }
1775
1776         return fsp;
1777 }
1778
1779 /****************************************************************************
1780  Close the fchmod file fd - ensure no locks are lost.
1781 ****************************************************************************/
1782
1783 int close_file_fchmod(files_struct *fsp)
1784 {
1785         int ret = fd_close(fsp->conn, fsp);
1786         file_free(fsp);
1787         return ret;
1788 }
1789
1790 /****************************************************************************
1791  Open a directory from an NT SMB call.
1792 ****************************************************************************/
1793
1794 files_struct *open_directory(connection_struct *conn,
1795                                 const char *fname,
1796                                 SMB_STRUCT_STAT *psbuf,
1797                                 uint32 access_mask,
1798                                 uint32 share_access,
1799                                 uint32 create_disposition,
1800                                 uint32 create_options,
1801                                 int *pinfo)
1802 {
1803         files_struct *fsp = NULL;
1804         BOOL dir_existed = VALID_STAT(*psbuf) ? True : False;
1805         BOOL create_dir = False;
1806         int info = 0;
1807
1808         DEBUG(5,("open_directory: opening directory %s, access_mask = 0x%x, "
1809                  "share_access = 0x%x create_options = 0x%x, "
1810                  "create_disposition = 0x%x\n",
1811                  fname,
1812                  (unsigned int)access_mask,
1813                  (unsigned int)share_access,
1814                  (unsigned int)create_options,
1815                  (unsigned int)create_disposition));
1816
1817         if (is_ntfs_stream_name(fname)) {
1818                 DEBUG(0,("open_directory: %s is a stream name!\n", fname ));
1819                 set_saved_ntstatus(NT_STATUS_NOT_A_DIRECTORY);
1820                 return NULL;
1821         }
1822
1823         if (dir_existed && !S_ISDIR(psbuf->st_mode)) {
1824                 DEBUG(0,("open_directory: %s is not a directory !\n", fname ));
1825                 set_saved_ntstatus(NT_STATUS_NOT_A_DIRECTORY);
1826                 return NULL;
1827         }
1828
1829         switch( create_disposition ) {
1830                 case FILE_OPEN:
1831                         /* If directory exists open. If directory doesn't
1832                          * exist error. */
1833                         if (!dir_existed) {
1834                                 DEBUG(5,("open_directory: FILE_OPEN requested "
1835                                          "for directory %s and it doesn't "
1836                                          "exist.\n", fname ));
1837                                 set_saved_ntstatus(NT_STATUS_OBJECT_NAME_NOT_FOUND);
1838                                 return NULL;
1839                         }
1840                         info = FILE_WAS_OPENED;
1841                         break;
1842
1843                 case FILE_CREATE:
1844                         /* If directory exists error. If directory doesn't
1845                          * exist create. */
1846                         if (dir_existed) {
1847                                 DEBUG(5,("open_directory: FILE_CREATE "
1848                                          "requested for directory %s and it "
1849                                          "already exists.\n", fname ));
1850                                 set_saved_error_triple(ERRDOS, ERRfilexists,
1851                                                        NT_STATUS_OBJECT_NAME_COLLISION);
1852                                 return NULL;
1853                         }
1854                         create_dir = True;
1855                         info = FILE_WAS_CREATED;
1856                         break;
1857
1858                 case FILE_OPEN_IF:
1859                         /* If directory exists open. If directory doesn't
1860                          * exist create. */
1861                         if (!dir_existed) {
1862                                 create_dir = True;
1863                                 info = FILE_WAS_CREATED;
1864                         } else {
1865                                 info = FILE_WAS_OPENED;
1866                         }
1867                         break;
1868
1869                 case FILE_SUPERSEDE:
1870                 case FILE_OVERWRITE:
1871                 case FILE_OVERWRITE_IF:
1872                 default:
1873                         DEBUG(5,("open_directory: invalid create_disposition "
1874                                  "0x%x for directory %s\n",
1875                                  (unsigned int)create_disposition, fname));
1876                         file_free(fsp);
1877                         set_saved_ntstatus(NT_STATUS_INVALID_PARAMETER);
1878                         return NULL;
1879         }
1880
1881         if (create_dir) {
1882                 /*
1883                  * Try and create the directory.
1884                  */
1885
1886                 /* We know bad_path is false as it's caught earlier. */
1887
1888                 NTSTATUS status = mkdir_internal(conn, fname, False);
1889
1890                 if (!NT_STATUS_IS_OK(status)) {
1891                         DEBUG(2,("open_directory: unable to create %s. "
1892                                  "Error was %s\n", fname, strerror(errno) ));
1893                         /* Ensure we return the correct NT status to the
1894                          * client. */
1895                         set_saved_error_triple(0, 0, status);
1896                         return NULL;
1897                 }
1898
1899                 /* Ensure we're checking for a symlink here.... */
1900                 /* We don't want to get caught by a symlink racer. */
1901
1902                 if(SMB_VFS_LSTAT(conn,fname, psbuf) != 0) {
1903                         return NULL;
1904                 }
1905
1906                 if(!S_ISDIR(psbuf->st_mode)) {
1907                         DEBUG(0,("open_directory: %s is not a directory !\n",
1908                                  fname ));
1909                         return NULL;
1910                 }
1911         }
1912
1913         fsp = file_new(conn);
1914         if(!fsp) {
1915                 return NULL;
1916         }
1917
1918         /*
1919          * Setup the files_struct for it.
1920          */
1921
1922         fsp->mode = psbuf->st_mode;
1923         fsp->inode = psbuf->st_ino;
1924         fsp->dev = psbuf->st_dev;
1925         fsp->vuid = current_user.vuid;
1926         fsp->file_pid = global_smbpid;
1927         fsp->can_lock = True;
1928         fsp->can_read = False;
1929         fsp->can_write = False;
1930
1931         fsp->share_access = share_access;
1932         fsp->fh->private_options = create_options;
1933         fsp->access_mask = access_mask;
1934
1935         fsp->print_file = False;
1936         fsp->modified = False;
1937         fsp->oplock_type = NO_OPLOCK;
1938         fsp->sent_oplock_break = NO_BREAK_SENT;
1939         fsp->is_directory = True;
1940         fsp->is_stat = False;
1941         string_set(&fsp->fsp_name,fname);
1942
1943         if (create_options & FILE_DELETE_ON_CLOSE) {
1944                 NTSTATUS status = can_set_delete_on_close(fsp, True, 0);
1945                 if (!NT_STATUS_IS_OK(status)) {
1946                         file_free(fsp);
1947                         return NULL;
1948                 }
1949         }
1950
1951         /* Change the owner if required. */
1952         if ((info == FILE_WAS_CREATED) && lp_inherit_owner(SNUM(conn))) {
1953                 change_owner_to_parent(conn, fsp, fsp->fsp_name, psbuf);
1954         }
1955
1956         if (pinfo) {
1957                 *pinfo = info;
1958         }
1959
1960         conn->num_files_open++;
1961
1962         return fsp;
1963 }
1964
1965 /****************************************************************************
1966  Open a pseudo-file (no locking checks - a 'stat' open).
1967 ****************************************************************************/
1968
1969 files_struct *open_file_stat(connection_struct *conn, char *fname,
1970                              SMB_STRUCT_STAT *psbuf)
1971 {
1972         files_struct *fsp = NULL;
1973
1974         if (!VALID_STAT(*psbuf))
1975                 return NULL;
1976
1977         /* Can't 'stat' open directories. */
1978         if(S_ISDIR(psbuf->st_mode))
1979                 return NULL;
1980
1981         fsp = file_new(conn);
1982         if(!fsp)
1983                 return NULL;
1984
1985         DEBUG(5,("open_file_stat: 'opening' file %s\n", fname));
1986
1987         /*
1988          * Setup the files_struct for it.
1989          */
1990
1991         fsp->mode = psbuf->st_mode;
1992         fsp->inode = psbuf->st_ino;
1993         fsp->dev = psbuf->st_dev;
1994         fsp->vuid = current_user.vuid;
1995         fsp->file_pid = global_smbpid;
1996         fsp->can_lock = False;
1997         fsp->can_read = False;
1998         fsp->can_write = False;
1999         fsp->print_file = False;
2000         fsp->modified = False;
2001         fsp->oplock_type = NO_OPLOCK;
2002         fsp->sent_oplock_break = NO_BREAK_SENT;
2003         fsp->is_directory = False;
2004         fsp->is_stat = True;
2005         string_set(&fsp->fsp_name,fname);
2006
2007         conn->num_files_open++;
2008
2009         return fsp;
2010 }