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
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20 */
  21
  22 #include "includes.h"
  23
  24 extern userdom_struct current_user_info;
  25 extern uint16 global_oplock_port;
  26 extern uint16 global_smbpid;
  27 extern BOOL global_client_failed_oplock_break;
  28
  29 /****************************************************************************
  30  fd support routines - attempt to do a dos_open.
  31 ****************************************************************************/
  32
  33 static int fd_open(struct connection_struct *conn, const char *fname,
  34                    int flags, mode_t mode)
  35 {
  36         int fd;
  37 #ifdef O_NOFOLLOW
  38         if (!lp_symlinks(SNUM(conn)))
  39                 flags |= O_NOFOLLOW;
  40 #endif
  41
  42         fd = SMB_VFS_OPEN(conn,fname,flags,mode);
  43
  44         DEBUG(10,("fd_open: name %s, flags = 0%o mode = 0%o, fd = %d. %s\n", fname,
  45                 flags, (int)mode, fd, (fd == -1) ? strerror(errno) : "" ));
  46
  47         return fd;
  48 }
  49
  50 /****************************************************************************
  51  Close the file associated with a fsp.
  52 ****************************************************************************/
  53
  54 int fd_close(struct connection_struct *conn, files_struct *fsp)
  55 {
  56         if (fsp->fd == -1)
  57                 return 0; /* what we used to call a stat open. */
  58         return fd_close_posix(conn, fsp);
  59 }
  60
  61
  62 /****************************************************************************
  63  Check a filename for the pipe string.
  64 ****************************************************************************/
  65
  66 static void check_for_pipe(const char *fname)
  67 {
  68         /* special case of pipe opens */
  69         char s[10];
  70         StrnCpy(s,fname,sizeof(s)-1);
  71         strlower_m(s);
  72         if (strstr(s,"pipe/")) {
  73                 DEBUG(3,("Rejecting named pipe open for %s\n",fname));
  74                 unix_ERR_class = ERRSRV;
  75                 unix_ERR_code = ERRaccess;
  76                 unix_ERR_ntstatus = NT_STATUS_ACCESS_DENIED;
  77         }
  78 }
  79
  80 /****************************************************************************
  81  Open a file.
  82 ****************************************************************************/
  83
  84 static BOOL open_file(files_struct *fsp,connection_struct *conn,
  85                       const char *fname,SMB_STRUCT_STAT *psbuf,int flags,mode_t mode, uint32 desired_access)
  86 {
  87         extern struct current_user current_user;
  88         int accmode = (flags & O_ACCMODE);
  89         int local_flags = flags;
  90
  91         fsp->fd = -1;
  92         fsp->oplock_type = NO_OPLOCK;
  93         errno = EPERM;
  94
  95         /* Check permissions */
  96
  97         /*
  98          * This code was changed after seeing a client open request
  99          * containing the open mode of (DENY_WRITE/read-only) with
 100          * the 'create if not exist' bit set. The previous code
 101          * would fail to open the file read only on a read-only share
 102          * as it was checking the flags parameter  directly against O_RDONLY,
 103          * this was failing as the flags parameter was set to O_RDONLY|O_CREAT.
 104          * JRA.
 105          */
 106
 107         if (!CAN_WRITE(conn)) {
 108                 /* It's a read-only share - fail if we wanted to write. */
 109                 if(accmode != O_RDONLY) {
 110                         DEBUG(3,("Permission denied opening %s\n",fname));
 111                         check_for_pipe(fname);
 112                         return False;
 113                 } else if(flags & O_CREAT) {
 114                         /* We don't want to write - but we must make sure that O_CREAT
 115                            doesn't create the file if we have write access into the
 116                            directory.
 117                         */
 118                         flags &= ~O_CREAT;
 119                         local_flags &= ~O_CREAT;
 120                 }
 121         }
 122
 123         /*
 124          * This little piece of insanity is inspired by the
 125          * fact that an NT client can open a file for O_RDONLY,
 126          * but set the create disposition to FILE_EXISTS_TRUNCATE.
 127          * If the client *can* write to the file, then it expects to
 128          * truncate the file, even though it is opening for readonly.
 129          * Quicken uses this stupid trick in backup file creation...
 130          * Thanks *greatly* to "David W. Chapman Jr." <dwcjr@inethouston.net>
 131          * for helping track this one down. It didn't bite us in 2.0.x
 132          * as we always opened files read-write in that release. JRA.
 133          */
 134
 135         if ((accmode == O_RDONLY) && ((flags & O_TRUNC) == O_TRUNC)) {
 136                 DEBUG(10,("open_file: truncate requested on read-only open for file %s\n",fname ));
 137                 local_flags = (flags & ~O_ACCMODE)|O_RDWR;
 138         }
 139
 140         if ((desired_access & (FILE_READ_DATA|FILE_WRITE_DATA|FILE_APPEND_DATA|FILE_EXECUTE)) ||
 141                         (local_flags & O_CREAT) || ((local_flags & O_TRUNC) == O_TRUNC) ) {
 142
 143                 /*
 144                  * We can't actually truncate here as the file may be locked.
 145                  * open_file_shared will take care of the truncate later. JRA.
 146                  */
 147
 148                 local_flags &= ~O_TRUNC;
 149
 150 #if defined(O_NONBLOCK) && defined(S_ISFIFO)
 151                 /*
 152                  * We would block on opening a FIFO with no one else on the
 153                  * other end. Do what we used to do and add O_NONBLOCK to the
 154                  * open flags. JRA.
 155                  */
 156
 157                 if (VALID_STAT(*psbuf) && S_ISFIFO(psbuf->st_mode))
 158                         local_flags |= O_NONBLOCK;
 159 #endif
 160
 161                 /* Don't create files with Microsoft wildcard characters. */
 162                 if ((local_flags & O_CREAT) && !VALID_STAT(*psbuf) && ms_has_wild(fname))  {
 163                         unix_ERR_class = ERRDOS;
 164                         unix_ERR_code = ERRinvalidname;
 165                         unix_ERR_ntstatus = NT_STATUS_OBJECT_NAME_INVALID;
 166                         return False;
 167                 }
 168
 169                 /* Actually do the open */
 170                 fsp->fd = fd_open(conn, fname, local_flags, mode);
 171                 if (fsp->fd == -1)  {
 172                         DEBUG(3,("Error opening file %s (%s) (local_flags=%d) (flags=%d)\n",
 173                                  fname,strerror(errno),local_flags,flags));
 174                         check_for_pipe(fname);
 175                         return False;
 176                 }
 177
 178                 /* Inherit the ACL if the file was created. */
 179                 if ((local_flags & O_CREAT) && !VALID_STAT(*psbuf))
 180                         inherit_access_acl(conn, fname, mode);
 181
 182         } else
 183                 fsp->fd = -1; /* What we used to call a stat open. */
 184
 185         if (!VALID_STAT(*psbuf)) {
 186                 int ret;
 187
 188                 if (fsp->fd == -1)
 189                         ret = SMB_VFS_STAT(conn, fname, psbuf);
 190                 else {
 191                         ret = SMB_VFS_FSTAT(fsp,fsp->fd,psbuf);
 192                         /* If we have an fd, this stat should succeed. */
 193                         if (ret == -1)
 194                                 DEBUG(0,("Error doing fstat on open file %s (%s)\n", fname,strerror(errno) ));
 195                 }
 196
 197                 /* For a non-io open, this stat failing means file not found. JRA */
 198                 if (ret == -1) {
 199                         fd_close(conn, fsp);
 200                         return False;
 201                 }
 202         }
 203
 204         /*
 205          * POSIX allows read-only opens of directories. We don't
 206          * want to do this (we use a different code path for this)
 207          * so catch a directory open and return an EISDIR. JRA.
 208          */
 209
 210         if(S_ISDIR(psbuf->st_mode)) {
 211                 fd_close(conn, fsp);
 212                 errno = EISDIR;
 213                 return False;
 214         }
 215
 216         fsp->mode = psbuf->st_mode;
 217         fsp->inode = psbuf->st_ino;
 218         fsp->dev = psbuf->st_dev;
 219         fsp->vuid = current_user.vuid;
 220         fsp->file_pid = global_smbpid;
 221         fsp->size = psbuf->st_size;
 222         fsp->can_lock = True;
 223         fsp->can_read = ((flags & O_WRONLY)==0);
 224         fsp->can_write = ((flags & (O_WRONLY|O_RDWR))!=0);
 225         fsp->share_mode = 0;
 226         fsp->desired_access = desired_access;
 227         fsp->print_file = False;
 228         fsp->modified = False;
 229         fsp->oplock_type = NO_OPLOCK;
 230         fsp->sent_oplock_break = NO_BREAK_SENT;
 231         fsp->is_directory = False;
 232         fsp->is_stat = False;
 233         fsp->directory_delete_on_close = False;
 234         string_set(&fsp->fsp_name,fname);
 235         fsp->wcp = NULL; /* Write cache pointer. */
 236
 237         DEBUG(2,("%s opened file %s read=%s write=%s (numopen=%d)\n",
 238                  *current_user_info.smb_name ? current_user_info.smb_name : conn->user,fsp->fsp_name,
 239                  BOOLSTR(fsp->can_read), BOOLSTR(fsp->can_write),
 240                  conn->num_files_open + 1));
 241
 242         return True;
 243 }
 244
 245 /****************************************************************************
 246   C. Hoch 11/22/95
 247   Helper for open_file_shared.
 248   Truncate a file after checking locking; close file if locked.
 249   **************************************************************************/
 250
 251 static int truncate_unless_locked(struct connection_struct *conn, files_struct *fsp)
 252 {
 253         SMB_BIG_UINT mask = (SMB_BIG_UINT)-1;
 254
 255         if (is_locked(fsp,fsp->conn,mask,0,WRITE_LOCK,True)){
 256                 errno = EACCES;
 257                 unix_ERR_class = ERRDOS;
 258                 unix_ERR_code = ERRlock;
 259                 unix_ERR_ntstatus = dos_to_ntstatus(ERRDOS, ERRlock);
 260                 return -1;
 261         } else {
 262                 return SMB_VFS_FTRUNCATE(fsp,fsp->fd,0);
 263         }
 264 }
 265
 266 /*******************************************************************
 267 return True if the filename is one of the special executable types
 268 ********************************************************************/
 269 static BOOL is_executable(const char *fname)
 270 {
 271         if ((fname = strrchr_m(fname,'.'))) {
 272                 if (strequal(fname,".com") ||
 273                     strequal(fname,".dll") ||
 274                     strequal(fname,".exe") ||
 275                     strequal(fname,".sym")) {
 276                         return True;
 277                 }
 278         }
 279         return False;
 280 }
 281
 282 enum {AFAIL,AREAD,AWRITE,AALL};
 283
 284 /*******************************************************************
 285 reproduce the share mode access table
 286 this is horrendoously complex, and really can't be justified on any
 287 rational grounds except that this is _exactly_ what NT does. See
 288 the DENY1 and DENY2 tests in smbtorture for a comprehensive set of
 289 test routines.
 290 ********************************************************************/
 291 static int access_table(int new_deny,int old_deny,int old_mode,
 292                         BOOL same_pid, BOOL isexe)
 293 {
 294           if (new_deny == DENY_ALL || old_deny == DENY_ALL) return(AFAIL);
 295
 296           if (same_pid) {
 297                   if (isexe && old_mode == DOS_OPEN_RDONLY &&
 298                       old_deny == DENY_DOS && new_deny == DENY_READ) {
 299                           return AFAIL;
 300                   }
 301                   if (!isexe && old_mode == DOS_OPEN_RDONLY &&
 302                       old_deny == DENY_DOS && new_deny == DENY_DOS) {
 303                           return AREAD;
 304                   }
 305                   if (new_deny == DENY_FCB && old_deny == DENY_DOS) {
 306                           if (isexe) return AFAIL;
 307                           if (old_mode == DOS_OPEN_RDONLY) return AFAIL;
 308                           return AALL;
 309                   }
 310                   if (old_mode == DOS_OPEN_RDONLY && old_deny == DENY_DOS) {
 311                           if (new_deny == DENY_FCB || new_deny == DENY_READ) {
 312                                   if (isexe) return AREAD;
 313                                   return AFAIL;
 314                           }
 315                   }
 316                   if (old_deny == DENY_FCB) {
 317                           if (new_deny == DENY_DOS || new_deny == DENY_FCB) return AALL;
 318                           return AFAIL;
 319                   }
 320           }
 321
 322           if (old_deny == DENY_DOS || new_deny == DENY_DOS ||
 323               old_deny == DENY_FCB || new_deny == DENY_FCB) {
 324                   if (isexe) {
 325                           if (old_deny == DENY_FCB || new_deny == DENY_FCB) {
 326                                   return AFAIL;
 327                           }
 328                           if (old_deny == DENY_DOS) {
 329                                   if (new_deny == DENY_READ &&
 330                                       (old_mode == DOS_OPEN_RDONLY ||
 331                                        old_mode == DOS_OPEN_RDWR)) {
 332                                           return AFAIL;
 333                                   }
 334                                   if (new_deny == DENY_WRITE &&
 335                                       (old_mode == DOS_OPEN_WRONLY ||
 336                                        old_mode == DOS_OPEN_RDWR)) {
 337                                           return AFAIL;
 338                                   }
 339                                   return AALL;
 340                           }
 341                           if (old_deny == DENY_NONE) return AALL;
 342                           if (old_deny == DENY_READ) return AWRITE;
 343                           if (old_deny == DENY_WRITE) return AREAD;
 344                   }
 345                   /* it isn't a exe, dll, sym or com file */
 346                   if (old_deny == new_deny && same_pid)
 347                           return(AALL);
 348
 349                   if (old_deny == DENY_READ || new_deny == DENY_READ) return AFAIL;
 350                   if (old_mode == DOS_OPEN_RDONLY) return(AREAD);
 351
 352                   return(AFAIL);
 353           }
 354
 355           switch (new_deny)
 356                   {
 357                   case DENY_WRITE:
 358                           if (old_deny==DENY_WRITE && old_mode==DOS_OPEN_RDONLY) return(AREAD);
 359                           if (old_deny==DENY_READ && old_mode==DOS_OPEN_RDONLY) return(AWRITE);
 360                           if (old_deny==DENY_NONE && old_mode==DOS_OPEN_RDONLY) return(AALL);
 361                           return(AFAIL);
 362                   case DENY_READ:
 363                           if (old_deny==DENY_WRITE && old_mode==DOS_OPEN_WRONLY) return(AREAD);
 364                           if (old_deny==DENY_READ && old_mode==DOS_OPEN_WRONLY) return(AWRITE);
 365                           if (old_deny==DENY_NONE && old_mode==DOS_OPEN_WRONLY) return(AALL);
 366                           return(AFAIL);
 367                   case DENY_NONE:
 368                           if (old_deny==DENY_WRITE) return(AREAD);
 369                           if (old_deny==DENY_READ) return(AWRITE);
 370                           if (old_deny==DENY_NONE) return(AALL);
 371                           return(AFAIL);
 372                   }
 373           return(AFAIL);
 374 }
 375
 376
 377 /****************************************************************************
 378 check if we can open a file with a share mode
 379 ****************************************************************************/
 380
 381 static BOOL check_share_mode(connection_struct *conn, share_mode_entry *share, int share_mode, uint32 desired_access,
 382                              const char *fname, BOOL fcbopen, int *flags)
 383 {
 384         int deny_mode = GET_DENY_MODE(share_mode);
 385         int old_open_mode = GET_OPEN_MODE(share->share_mode);
 386         int old_deny_mode = GET_DENY_MODE(share->share_mode);
 387
 388         /*
 389          * share modes = false means don't bother to check for
 390          * DENY mode conflict. This is a *really* bad idea :-). JRA.
 391          */
 392
 393         if(!lp_share_modes(SNUM(conn)))
 394                 return True;
 395
 396         /*
 397          * Don't allow any opens once the delete on close flag has been
 398          * set.
 399          */
 400
 401         if (GET_DELETE_ON_CLOSE_FLAG(share->share_mode)) {
 402                 DEBUG(5,("check_share_mode: Failing open on file %s as delete on close flag is set.\n",
 403                         fname ));
 404                 /* Use errno to map to correct error. */
 405                 unix_ERR_class = SMB_SUCCESS;
 406                 unix_ERR_code = 0;
 407                 unix_ERR_ntstatus = NT_STATUS_OK;
 408                 return False;
 409         }
 410
 411         /* this is a nasty hack, but necessary until we rewrite our open
 412            handling to use a NTCreateX call as the basic call.
 413            NT may open a file with neither read nor write access, and in
 414                    this case it expects the open not to conflict with any
 415                    existing deny modes. This happens (for example) during a
 416                    "xcopy /o" where the second file descriptor is used for
 417                    ACL sets
 418                    (tridge)
 419         */
 420
 421         /*
 422          * This is a bit wierd - the test for desired access not having the
 423          * critical bits seems seems odd. Firstly, if both opens have no
 424          * critical bits then always ignore. Then check the "allow delete"
 425          * then check for either. This probably isn't quite right yet but
 426          * gets us much closer. JRA.
 427          */
 428
 429         /*
 430          * If desired_access doesn't contain READ_DATA,WRITE_DATA,APPEND_DATA or EXECUTE
 431          * and the existing desired_acces then share modes don't conflict.
 432          */
 433
 434         if ( !(desired_access & (FILE_READ_DATA|FILE_WRITE_DATA|FILE_APPEND_DATA|FILE_EXECUTE)) &&
 435                 !(share->desired_access & (FILE_READ_DATA|FILE_WRITE_DATA|FILE_APPEND_DATA|FILE_EXECUTE)) ) {
 436
 437                 /*
 438                  * Wrinkle discovered by smbtorture....
 439                  * If both are non-io open and requester is asking for delete and current open has delete access
 440                  * but neither open has allowed file share delete then deny.... this is very strange and
 441                  * seems to be the only case in which non-io opens conflict. JRA.
 442                  */
 443
 444                 if ((desired_access & DELETE_ACCESS) && (share->desired_access & DELETE_ACCESS) &&
 445                                 (!GET_ALLOW_SHARE_DELETE(share->share_mode) || !GET_ALLOW_SHARE_DELETE(share_mode))) {
 446                         DEBUG(5,("check_share_mode: Failing open on file %s as delete access requests conflict.\n",
 447                                 fname ));
 448                         unix_ERR_class = ERRDOS;
 449                         unix_ERR_code = ERRbadshare;
 450                         unix_ERR_ntstatus = NT_STATUS_SHARING_VIOLATION;
 451
 452                         return False;
 453                 }
 454
 455                 DEBUG(5,("check_share_mode: Allowing open on file %s as both desired access (0x%x) \
 456 and existing desired access (0x%x) are non-data opens\n",
 457                         fname, (unsigned int)desired_access, (unsigned int)share->desired_access ));
 458                 return True;
 459         }
 460
 461         /*
 462          * If delete access was requested and the existing share mode doesn't have
 463          * ALLOW_SHARE_DELETE then deny.
 464          */
 465
 466         if ((desired_access & DELETE_ACCESS) && !GET_ALLOW_SHARE_DELETE(share->share_mode)) {
 467                 DEBUG(5,("check_share_mode: Failing open on file %s as delete access requested and allow share delete not set.\n",
 468                         fname ));
 469                 unix_ERR_class = ERRDOS;
 470                 unix_ERR_code = ERRbadshare;
 471                 unix_ERR_ntstatus = NT_STATUS_SHARING_VIOLATION;
 472
 473                 return False;
 474         }
 475
 476         /*
 477          * The inverse of the above.
 478          * If delete access was granted and the new share mode doesn't have
 479          * ALLOW_SHARE_DELETE then deny.
 480          */
 481
 482         if ((share->desired_access & DELETE_ACCESS) && !GET_ALLOW_SHARE_DELETE(share_mode)) {
 483                 DEBUG(5,("check_share_mode: Failing open on file %s as delete access granted and allow share delete not requested.\n",
 484                         fname ));
 485                 unix_ERR_class = ERRDOS;
 486                 unix_ERR_code = ERRbadshare;
 487                 unix_ERR_ntstatus = NT_STATUS_SHARING_VIOLATION;
 488
 489                 return False;
 490         }
 491
 492         /*
 493          * If desired_access doesn't contain READ_DATA,WRITE_DATA,APPEND_DATA or EXECUTE
 494          * then share modes don't conflict. Likewise with existing desired access.
 495          */
 496
 497         if ( !(desired_access & (FILE_READ_DATA|FILE_WRITE_DATA|FILE_APPEND_DATA|FILE_EXECUTE)) ||
 498                 !(share->desired_access & (FILE_READ_DATA|FILE_WRITE_DATA|FILE_APPEND_DATA|FILE_EXECUTE)) ) {
 499                 DEBUG(5,("check_share_mode: Allowing open on file %s as desired access (0x%x) doesn't conflict with\
 500 existing desired access (0x%x).\n", fname, (unsigned int)desired_access, (unsigned int)share->desired_access ));
 501                 return True;
 502         }
 503
 504         {
 505                 int access_allowed = access_table(deny_mode,old_deny_mode,old_open_mode,
 506                                                 (share->pid == sys_getpid()),is_executable(fname));
 507
 508                 if ((access_allowed == AFAIL) ||
 509                         (!fcbopen && (access_allowed == AREAD && *flags == O_RDWR)) ||
 510                         (access_allowed == AREAD && *flags != O_RDONLY) ||
 511                         (access_allowed == AWRITE && *flags != O_WRONLY)) {
 512
 513                         DEBUG(2,("Share violation on file (%d,%d,%d,%d,%s,fcbopen = %d, flags = %d) = %d\n",
 514                                 deny_mode,old_deny_mode,old_open_mode,
 515                                 (int)share->pid,fname, fcbopen, *flags, access_allowed));
 516
 517                         unix_ERR_class = ERRDOS;
 518                         unix_ERR_code = ERRbadshare;
 519                         unix_ERR_ntstatus = NT_STATUS_SHARING_VIOLATION;
 520
 521                         return False;
 522                 }
 523
 524                 if (access_allowed == AREAD)
 525                         *flags = O_RDONLY;
 526
 527                 if (access_allowed == AWRITE)
 528                         *flags = O_WRONLY;
 529
 530         }
 531
 532         return True;
 533 }
 534
 535
 536 #if defined(DEVELOPER)
 537 static void validate_my_share_entries(int num, share_mode_entry *share_entry)
 538 {
 539         files_struct *fsp;
 540
 541         if (share_entry->pid != sys_getpid())
 542                 return;
 543
 544         fsp = file_find_dif(share_entry->dev, share_entry->inode, share_entry->share_file_id);
 545         if (!fsp) {
 546                 DEBUG(0,("validate_my_share_entries: PANIC : %s\n", share_mode_str(num, share_entry) ));
 547                 smb_panic("validate_my_share_entries: Cannot match a share entry with an open file\n");
 548         }
 549
 550         if (((uint16)fsp->oplock_type) != share_entry->op_type) {
 551                 pstring str;
 552                 DEBUG(0,("validate_my_share_entries: PANIC : %s\n", share_mode_str(num, share_entry) ));
 553                 slprintf(str, sizeof(str)-1, "validate_my_share_entries: file %s, oplock_type = 0x%x, op_type = 0x%x\n",
 554                                 fsp->fsp_name, (unsigned int)fsp->oplock_type, (unsigned int)share_entry->op_type );
 555                 smb_panic(str);
 556         }
 557 }
 558 #endif
 559
 560 /****************************************************************************
 561  Deal with open deny mode and oplock break processing.
 562  Invarient: Share mode must be locked on entry and exit.
 563  Returns -1 on error, or number of share modes on success (may be zero).
 564 ****************************************************************************/
 565
 566 static int open_mode_check(connection_struct *conn, const char *fname, SMB_DEV_T dev,
 567                            SMB_INO_T inode,
 568                            uint32 desired_access,
 569                            int share_mode, int *p_flags, int *p_oplock_request,
 570                            BOOL *p_all_current_opens_are_level_II)
 571 {
 572         int i;
 573         int num_share_modes;
 574         int oplock_contention_count = 0;
 575         share_mode_entry *old_shares = 0;
 576         BOOL fcbopen = False;
 577         BOOL broke_oplock;
 578
 579         if(GET_OPEN_MODE(share_mode) == DOS_OPEN_FCB)
 580                 fcbopen = True;
 581
 582         num_share_modes = get_share_modes(conn, dev, inode, &old_shares);
 583
 584         if(num_share_modes == 0)
 585                 return 0;
 586
 587         /*
 588          * Check if the share modes will give us access.
 589          */
 590
 591         do {
 592                 share_mode_entry broken_entry;
 593
 594                 broke_oplock = False;
 595                 *p_all_current_opens_are_level_II = True;
 596
 597                 for(i = 0; i < num_share_modes; i++) {
 598                         share_mode_entry *share_entry = &old_shares[i];
 599
 600 #if defined(DEVELOPER)
 601                         validate_my_share_entries(i, share_entry);
 602 #endif
 603
 604                         /*
 605                          * By observation of NetBench, oplocks are broken *before* share
 606                          * modes are checked. This allows a file to be closed by the client
 607                          * if the share mode would deny access and the client has an oplock.
 608                          * Check if someone has an oplock on this file. If so we must break
 609                          * it before continuing.
 610                          */
 611
 612                         if((*p_oplock_request && EXCLUSIVE_OPLOCK_TYPE(share_entry->op_type)) ||
 613                            (!*p_oplock_request && (share_entry->op_type != NO_OPLOCK))) {
 614
 615                                 BOOL opb_ret;
 616
 617                                 DEBUG(5,("open_mode_check: oplock_request = %d, breaking oplock (%x) on file %s, \
 618 dev = %x, inode = %.0f\n", *p_oplock_request, share_entry->op_type, fname, (unsigned int)dev, (double)inode));
 619
 620                                 /* Ensure the reply for the open uses the correct sequence number. */
 621                                 /* This isn't a real deferred packet as it's response will also increment
 622                                  * the sequence.
 623                                  */
 624                                 srv_defer_sign_response(get_current_mid());
 625
 626                                 /* Oplock break - unlock to request it. */
 627                                 unlock_share_entry(conn, dev, inode);
 628
 629                                 opb_ret = request_oplock_break(share_entry, False);
 630
 631                                 /* Now relock. */
 632                                 lock_share_entry(conn, dev, inode);
 633
 634                                 if(opb_ret == False) {
 635                                         DEBUG(0,("open_mode_check: FAILED when breaking oplock (%x) on file %s, \
 636 dev = %x, inode = %.0f\n", old_shares[i].op_type, fname, (unsigned int)dev, (double)inode));
 637                                         SAFE_FREE(old_shares);
 638                                         errno = EACCES;
 639                                         unix_ERR_class = ERRDOS;
 640                                         unix_ERR_code = ERRbadshare;
 641                                         unix_ERR_ntstatus = NT_STATUS_SHARING_VIOLATION;
 642                                         return -1;
 643                                 }
 644
 645                                 broke_oplock = True;
 646                                 broken_entry = *share_entry;
 647                                 break;
 648
 649                         } else if (!LEVEL_II_OPLOCK_TYPE(share_entry->op_type)) {
 650                                 *p_all_current_opens_are_level_II = False;
 651                         }
 652
 653                         /* someone else has a share lock on it, check to see if we can too */
 654                         if (!check_share_mode(conn, share_entry, share_mode, desired_access,
 655                                                 fname, fcbopen, p_flags)) {
 656                                 SAFE_FREE(old_shares);
 657                                 errno = EACCES;
 658                                 return -1;
 659                         }
 660
 661                 } /* end for */
 662
 663                 if(broke_oplock) {
 664                         SAFE_FREE(old_shares);
 665                         num_share_modes = get_share_modes(conn, dev, inode, &old_shares);
 666                         oplock_contention_count++;
 667
 668                         /* Paranoia check that this is no longer an exlusive entry. */
 669                         for(i = 0; i < num_share_modes; i++) {
 670                                 share_mode_entry *share_entry = &old_shares[i];
 671
 672                                 if (share_modes_identical(&broken_entry, share_entry) &&
 673                                     EXCLUSIVE_OPLOCK_TYPE(share_entry->op_type) ) {
 674
 675                                         /*
 676                                          * This should not happen. The target left this oplock
 677                                          * as exlusive.... The process *must* be dead....
 678                                          */
 679
 680                                         DEBUG(0,("open_mode_check: exlusive oplock left by process %d after break ! For file %s, \
 681 dev = %x, inode = %.0f. Deleting it to continue...\n", (int)broken_entry.pid, fname, (unsigned int)dev, (double)inode));
 682
 683                                         if (process_exists(broken_entry.pid)) {
 684                                                 DEBUG(0,("open_mode_check: Existent process %lu left active oplock.\n",
 685                                                          (unsigned long)broken_entry.pid ));
 686                                         }
 687
 688                                         if (del_share_entry(dev, inode, &broken_entry, NULL) == -1) {
 689                                                 errno = EACCES;
 690                                                 unix_ERR_class = ERRDOS;
 691                                                 unix_ERR_code = ERRbadshare;
 692                                                 unix_ERR_ntstatus = NT_STATUS_SHARING_VIOLATION;
 693                                                 return -1;
 694                                         }
 695
 696                                         /*
 697                                          * We must reload the share modes after deleting the
 698                                          * other process's entry.
 699                                          */
 700
 701                                         SAFE_FREE(old_shares);
 702                                         num_share_modes = get_share_modes(conn, dev, inode, &old_shares);
 703                                         break;
 704                                 }
 705                         } /* end for paranoia... */
 706                 } /* end if broke_oplock */
 707
 708         } while(broke_oplock);
 709
 710         if(old_shares != 0)
 711                 SAFE_FREE(old_shares);
 712
 713         /*
 714          * Refuse to grant an oplock in case the contention limit is
 715          * reached when going through the lock list multiple times.
 716          */
 717
 718         if(oplock_contention_count >= lp_oplock_contention_limit(SNUM(conn))) {
 719                 *p_oplock_request = 0;
 720                 DEBUG(4,("open_mode_check: oplock contention = %d. Not granting oplock.\n",
 721                          oplock_contention_count ));
 722         }
 723
 724         return num_share_modes;
 725 }
 726
 727 /****************************************************************************
 728 set a kernel flock on a file for NFS interoperability
 729 this requires a patch to Linux
 730 ****************************************************************************/
 731 static void kernel_flock(files_struct *fsp, int deny_mode)
 732 {
 733 #if HAVE_KERNEL_SHARE_MODES
 734         int kernel_mode = 0;
 735         if (deny_mode == DENY_READ) kernel_mode = LOCK_MAND|LOCK_WRITE;
 736         else if (deny_mode == DENY_WRITE) kernel_mode = LOCK_MAND|LOCK_READ;
 737         else if (deny_mode == DENY_ALL) kernel_mode = LOCK_MAND;
 738         if (kernel_mode) flock(fsp->fd, kernel_mode);
 739 #endif
 740         ;;
 741 }
 742
 743
 744 static BOOL open_match_attributes(connection_struct *conn, const char *path, uint32 old_dos_mode, uint32 new_dos_mode,
 745                 mode_t existing_mode, mode_t new_mode, mode_t *returned_mode)
 746 {
 747         uint32 noarch_old_dos_mode, noarch_new_dos_mode;
 748
 749         noarch_old_dos_mode = (old_dos_mode & ~FILE_ATTRIBUTE_ARCHIVE);
 750         noarch_new_dos_mode = (new_dos_mode & ~FILE_ATTRIBUTE_ARCHIVE);
 751
 752         if((noarch_old_dos_mode == 0 && noarch_new_dos_mode != 0) ||
 753            (noarch_old_dos_mode != 0 && ((noarch_old_dos_mode & noarch_new_dos_mode) == noarch_old_dos_mode)))
 754                 *returned_mode = new_mode;
 755         else
 756                 *returned_mode = (mode_t)0;
 757
 758         DEBUG(10,("open_match_attributes: file %s old_dos_mode = 0x%x, existing_mode = 0%o, new_dos_mode = 0x%x returned_mode = 0%o\n",
 759                 path,
 760                 old_dos_mode, (unsigned int)existing_mode, new_dos_mode, (unsigned int)*returned_mode ));
 761
 762         /* If we're mapping SYSTEM and HIDDEN ensure they match. */
 763         if (lp_map_system(SNUM(conn)) || lp_store_dos_attributes(SNUM(conn))) {
 764                 if ((old_dos_mode & FILE_ATTRIBUTE_SYSTEM) && !(new_dos_mode & FILE_ATTRIBUTE_SYSTEM))
 765                         return False;
 766         }
 767         if (lp_map_hidden(SNUM(conn)) || lp_store_dos_attributes(SNUM(conn))) {
 768                 if ((old_dos_mode & FILE_ATTRIBUTE_HIDDEN) && !(new_dos_mode & FILE_ATTRIBUTE_HIDDEN))
 769                         return False;
 770         }
 771         return True;
 772 }
 773
 774 /****************************************************************************
 775  Open a file with a share mode.
 776 ****************************************************************************/
 777
 778 files_struct *open_file_shared(connection_struct *conn,char *fname, SMB_STRUCT_STAT *psbuf,
 779                                int share_mode,int ofun, uint32 new_dos_mode, int oplock_request,
 780                                int *Access,int *action)
 781 {
 782         return open_file_shared1(conn, fname, psbuf, 0, share_mode, ofun, new_dos_mode,
 783                                  oplock_request, Access, action);
 784 }
 785
 786 /****************************************************************************
 787  Open a file with a share mode.
 788 ****************************************************************************/
 789
 790 files_struct *open_file_shared1(connection_struct *conn,char *fname, SMB_STRUCT_STAT *psbuf,
 791                                 uint32 desired_access,
 792                                 int share_mode,int ofun, uint32 new_dos_mode,
 793                                 int oplock_request,
 794                                 int *Access,int *paction)
 795 {
 796         int flags=0;
 797         int flags2=0;
 798         int deny_mode = GET_DENY_MODE(share_mode);
 799         BOOL allow_share_delete = GET_ALLOW_SHARE_DELETE(share_mode);
 800         BOOL delete_on_close = GET_DELETE_ON_CLOSE_FLAG(share_mode);
 801         BOOL file_existed = VALID_STAT(*psbuf);
 802         BOOL fcbopen = False;
 803         BOOL def_acl = False;
 804         SMB_DEV_T dev = 0;
 805         SMB_INO_T inode = 0;
 806         int num_share_modes = 0;
 807         BOOL all_current_opens_are_level_II = False;
 808         BOOL fsp_open = False;
 809         files_struct *fsp = NULL;
 810         int open_mode=0;
 811         uint16 port = 0;
 812         mode_t new_mode = (mode_t)0;
 813         int action;
 814         uint32 existing_dos_mode = 0;
 815         /* We add aARCH to this as this mode is only used if the file is created new. */
 816         mode_t mode = unix_mode(conn,new_dos_mode | aARCH,fname);
 817
 818         if (conn->printer) {
 819                 /* printers are handled completely differently. Most of the passed parameters are
 820                         ignored */
 821                 if (Access)
 822                         *Access = DOS_OPEN_WRONLY;
 823                 if (action)
 824                         *paction = FILE_WAS_CREATED;
 825                 return print_fsp_open(conn, fname);
 826         }
 827
 828         fsp = file_new(conn);
 829         if(!fsp)
 830                 return NULL;
 831
 832         DEBUG(10,("open_file_shared: fname = %s, dos_attrs = %x, share_mode = %x, ofun = %x, mode = %o, oplock request = %d\n",
 833                 fname, new_dos_mode, share_mode, ofun, (int)mode,  oplock_request ));
 834
 835         if (!check_name(fname,conn)) {
 836                 file_free(fsp);
 837                 return NULL;
 838         }
 839
 840         new_dos_mode &= SAMBA_ATTRIBUTES_MASK;
 841         if (file_existed) {
 842                 existing_dos_mode = dos_mode(conn, fname, psbuf);
 843         }
 844
 845         /* ignore any oplock requests if oplocks are disabled */
 846         if (!lp_oplocks(SNUM(conn)) || global_client_failed_oplock_break) {
 847                 oplock_request = 0;
 848         }
 849
 850         /* this is for OS/2 EAs - try and say we don't support them */
 851         if (strstr(fname,".+,;=[].")) {
 852                 unix_ERR_class = ERRDOS;
 853                 /* OS/2 Workplace shell fix may be main code stream in a later release. */
 854 #if 1 /* OS2_WPS_FIX - Recent versions of OS/2 need this. */
 855                 unix_ERR_code = ERRcannotopen;
 856 #else /* OS2_WPS_FIX */
 857                 unix_ERR_code = ERROR_EAS_NOT_SUPPORTED;
 858 #endif /* OS2_WPS_FIX */
 859
 860                 DEBUG(5,("open_file_shared: OS/2 EA's are not supported.\n"));
 861                 file_free(fsp);
 862                 return NULL;
 863         }
 864
 865         if ((GET_FILE_OPEN_DISPOSITION(ofun) == FILE_EXISTS_FAIL) && file_existed)  {
 866                 DEBUG(5,("open_file_shared: create new requested for file %s and file already exists.\n",
 867                         fname ));
 868                 file_free(fsp);
 869                 if (S_ISDIR(psbuf->st_mode)) {
 870                         errno = EISDIR;
 871                 } else {
 872                         errno = EEXIST;
 873                 }
 874                 return NULL;
 875         }
 876
 877         if (CAN_WRITE(conn) && (GET_FILE_CREATE_DISPOSITION(ofun) == FILE_CREATE_IF_NOT_EXIST))
 878                 flags2 |= O_CREAT;
 879
 880         if (CAN_WRITE(conn) && (GET_FILE_OPEN_DISPOSITION(ofun) == FILE_EXISTS_TRUNCATE))
 881                 flags2 |= O_TRUNC;
 882
 883         /* We only care about matching attributes on file exists and truncate. */
 884         if (file_existed && (GET_FILE_OPEN_DISPOSITION(ofun) == FILE_EXISTS_TRUNCATE)) {
 885                 if (!open_match_attributes(conn, fname, existing_dos_mode, new_dos_mode,
 886                                         psbuf->st_mode, mode, &new_mode)) {
 887                         DEBUG(5,("open_file_shared: attributes missmatch for file %s (%x %x) (0%o, 0%o)\n",
 888                                                 fname, existing_dos_mode, new_dos_mode,
 889                                                 (int)psbuf->st_mode, (int)mode ));
 890                         file_free(fsp);
 891                         errno = EACCES;
 892                         return NULL;
 893                 }
 894         }
 895
 896         if (GET_FILE_OPEN_DISPOSITION(ofun) == FILE_EXISTS_FAIL)
 897                 flags2 |= O_EXCL;
 898
 899         /* note that we ignore the append flag as
 900                 append does not mean the same thing under dos and unix */
 901
 902         switch (GET_OPEN_MODE(share_mode)) {
 903                 case DOS_OPEN_WRONLY:
 904                         flags = O_WRONLY;
 905                         if (desired_access == 0)
 906                                 desired_access = FILE_WRITE_DATA;
 907                         break;
 908                 case DOS_OPEN_FCB:
 909                         fcbopen = True;
 910                         flags = O_RDWR;
 911                         if (desired_access == 0)
 912                                 desired_access = FILE_READ_DATA|FILE_WRITE_DATA;
 913                         break;
 914                 case DOS_OPEN_RDWR:
 915                         flags = O_RDWR;
 916                         if (desired_access == 0)
 917                                 desired_access = FILE_READ_DATA|FILE_WRITE_DATA;
 918                         break;
 919                 default:
 920                         flags = O_RDONLY;
 921                         if (desired_access == 0)
 922                                 desired_access = FILE_READ_DATA;
 923                         break;
 924         }
 925
 926 #if defined(O_SYNC)
 927         if (GET_FILE_SYNC_OPENMODE(share_mode)) {
 928                 flags2 |= O_SYNC;
 929         }
 930 #endif /* O_SYNC */
 931
 932         if (flags != O_RDONLY && file_existed &&
 933                         (!CAN_WRITE(conn) || IS_DOS_READONLY(existing_dos_mode))) {
 934                 if (!fcbopen) {
 935                         DEBUG(5,("open_file_shared: read/write access requested for file %s on read only %s\n",
 936                                 fname, !CAN_WRITE(conn) ? "share" : "file" ));
 937                         file_free(fsp);
 938                         errno = EACCES;
 939                         return NULL;
 940                 }
 941                 flags = O_RDONLY;
 942         }
 943
 944         if (deny_mode > DENY_NONE && deny_mode!=DENY_FCB) {
 945                 DEBUG(2,("Invalid deny mode %d on file %s\n",deny_mode,fname));
 946                 file_free(fsp);
 947                 errno = EINVAL;
 948                 return NULL;
 949         }
 950
 951         if (file_existed) {
 952
 953                 dev = psbuf->st_dev;
 954                 inode = psbuf->st_ino;
 955
 956                 lock_share_entry(conn, dev, inode);
 957
 958                 num_share_modes = open_mode_check(conn, fname, dev, inode,
 959                                                   desired_access,
 960                                                   share_mode,
 961                                                   &flags, &oplock_request, &all_current_opens_are_level_II);
 962                 if(num_share_modes == -1) {
 963
 964                         /*
 965                          * This next line is a subtlety we need for MS-Access. If a file open will
 966                          * fail due to share permissions and also for security (access)
 967                          * reasons, we need to return the access failed error, not the
 968                          * share error. This means we must attempt to open the file anyway
 969                          * in order to get the UNIX access error - even if we're going to
 970                          * fail the open for share reasons. This is bad, as we're burning
 971                          * another fd if there are existing locks but there's nothing else
 972                          * we can do. We also ensure we're not going to create or tuncate
 973                          * the file as we only want an access decision at this stage. JRA.
 974                          */
 975                         errno = 0;
 976                         fsp_open = open_file(fsp,conn,fname,psbuf,
 977                                                 flags|(flags2&~(O_TRUNC|O_CREAT)),mode,desired_access);
 978
 979                         DEBUG(4,("open_file_shared : share_mode deny - calling open_file with \
 980 flags=0x%X flags2=0x%X mode=0%o returned %d\n",
 981                                 flags,(flags2&~(O_TRUNC|O_CREAT)),(int)mode,(int)fsp_open ));
 982
 983                         if (!fsp_open && errno) {
 984                                 unix_ERR_class = ERRDOS;
 985                                 unix_ERR_code = ERRnoaccess;
 986                                 unix_ERR_ntstatus = NT_STATUS_ACCESS_DENIED;
 987                         }
 988
 989                         unlock_share_entry(conn, dev, inode);
 990                         if (fsp_open)
 991                                 fd_close(conn, fsp);
 992                         file_free(fsp);
 993                         return NULL;
 994                 }
 995
 996                 /*
 997                  * We exit this block with the share entry *locked*.....
 998                  */
 999         }
1000
1001         /*
1002          * Ensure we pay attention to default ACLs on directories if required.
1003          */
1004
1005         if ((flags2 & O_CREAT) && lp_inherit_acls(SNUM(conn)) &&
1006                         (def_acl = directory_has_default_acl(conn, parent_dirname(fname))))
1007                 mode = 0777;
1008
1009         DEBUG(4,("calling open_file with flags=0x%X flags2=0x%X mode=0%o\n",
1010                         flags,flags2,(int)mode));
1011
1012         /*
1013          * open_file strips any O_TRUNC flags itself.
1014          */
1015
1016         fsp_open = open_file(fsp,conn,fname,psbuf,flags|flags2,mode,desired_access);
1017
1018         if (!fsp_open && (flags == O_RDWR) && (errno != ENOENT) && fcbopen) {
1019                 if((fsp_open = open_file(fsp,conn,fname,psbuf,O_RDONLY,mode,desired_access)) == True)
1020                         flags = O_RDONLY;
1021         }
1022
1023         if (!fsp_open) {
1024                 if(file_existed)
1025                         unlock_share_entry(conn, dev, inode);
1026                 file_free(fsp);
1027                 return NULL;
1028         }
1029
1030         /*
1031          * Deal with the race condition where two smbd's detect the file doesn't
1032          * exist and do the create at the same time. One of them will win and
1033          * set a share mode, the other (ie. this one) should check if the
1034          * requested share mode for this create is allowed.
1035          */
1036
1037         if (!file_existed) {
1038
1039                 /*
1040                  * Now the file exists and fsp is successfully opened,
1041                  * fsp->dev and fsp->inode are valid and should replace the
1042                  * dev=0,inode=0 from a non existent file. Spotted by
1043                  * Nadav Danieli <nadavd@exanet.com>. JRA.
1044                  */
1045
1046                 dev = fsp->dev;
1047                 inode = fsp->inode;
1048
1049                 lock_share_entry_fsp(fsp);
1050
1051                 num_share_modes = open_mode_check(conn, fname, dev, inode,
1052                                                   desired_access,
1053                                                   share_mode,
1054                                                   &flags, &oplock_request, &all_current_opens_are_level_II);
1055
1056                 if(num_share_modes == -1) {
1057                         unlock_share_entry_fsp(fsp);
1058                         fd_close(conn,fsp);
1059                         file_free(fsp);
1060                         return NULL;
1061                 }
1062
1063                 /*
1064                  * If there are any share modes set then the file *did*
1065                  * exist. Ensure we return the correct value for action.
1066                  */
1067
1068                 if (num_share_modes > 0)
1069                         file_existed = True;
1070
1071                 /*
1072                  * We exit this block with the share entry *locked*.....
1073                  */
1074         }
1075
1076         /* note that we ignore failure for the following. It is
1077            basically a hack for NFS, and NFS will never set one of
1078            these only read them. Nobody but Samba can ever set a deny
1079            mode and we have already checked our more authoritative
1080            locking database for permission to set this deny mode. If
1081            the kernel refuses the operations then the kernel is wrong */
1082         kernel_flock(fsp, deny_mode);
1083
1084         /*
1085          * At this point onwards, we can guarentee that the share entry
1086          * is locked, whether we created the file or not, and that the
1087          * deny mode is compatible with all current opens.
1088          */
1089
1090         /*
1091          * If requested, truncate the file.
1092          */
1093
1094         if (flags2&O_TRUNC) {
1095                 /*
1096                  * We are modifing the file after open - update the stat struct..
1097                  */
1098                 if ((truncate_unless_locked(conn,fsp) == -1) || (SMB_VFS_FSTAT(fsp,fsp->fd,psbuf)==-1)) {
1099                         unlock_share_entry_fsp(fsp);
1100                         fd_close(conn,fsp);
1101                         file_free(fsp);
1102                         return NULL;
1103                 }
1104         }
1105
1106         switch (flags) {
1107                 case O_RDONLY:
1108                         open_mode = DOS_OPEN_RDONLY;
1109                         break;
1110                 case O_RDWR:
1111                         open_mode = DOS_OPEN_RDWR;
1112                         break;
1113                 case O_WRONLY:
1114                         open_mode = DOS_OPEN_WRONLY;
1115                         break;
1116         }
1117
1118         fsp->share_mode = SET_DENY_MODE(deny_mode) |
1119                                                 SET_OPEN_MODE(open_mode) |
1120                                                 SET_ALLOW_SHARE_DELETE(allow_share_delete);
1121
1122         DEBUG(10,("open_file_shared : share_mode = %x\n", fsp->share_mode ));
1123
1124         if (Access) {
1125                 (*Access) = open_mode;
1126         }
1127
1128         if (file_existed && !(flags2 & O_TRUNC))
1129                 action = FILE_WAS_OPENED;
1130         if (file_existed && (flags2 & O_TRUNC))
1131                 action = FILE_WAS_OVERWRITTEN;
1132         if (!file_existed)
1133                 action = FILE_WAS_CREATED;
1134
1135         if (paction) {
1136                 *paction = action;
1137         }
1138
1139         /*
1140          * Setup the oplock info in both the shared memory and
1141          * file structs.
1142          */
1143
1144         if(oplock_request && (num_share_modes == 0) &&
1145                         !IS_VETO_OPLOCK_PATH(conn,fname) && set_file_oplock(fsp, oplock_request) ) {
1146                 port = global_oplock_port;
1147         } else if (oplock_request && all_current_opens_are_level_II) {
1148                 port = global_oplock_port;
1149                 oplock_request = LEVEL_II_OPLOCK;
1150                 set_file_oplock(fsp, oplock_request);
1151         } else {
1152                 port = 0;
1153                 oplock_request = 0;
1154         }
1155
1156         set_share_mode(fsp, port, oplock_request);
1157
1158         if (delete_on_close) {
1159                 NTSTATUS result = set_delete_on_close_internal(fsp, delete_on_close);
1160
1161                 if (NT_STATUS_V(result) !=  NT_STATUS_V(NT_STATUS_OK)) {
1162                         /* Remember to delete the mode we just added. */
1163                         del_share_mode(fsp, NULL);
1164                         unlock_share_entry_fsp(fsp);
1165                         fd_close(conn,fsp);
1166                         file_free(fsp);
1167                         return NULL;
1168                 }
1169         }
1170
1171         if (action == FILE_WAS_OVERWRITTEN || action == FILE_WAS_CREATED) {
1172                 /* Files should be initially set as archive */
1173                 if (lp_map_archive(SNUM(conn)) || lp_store_dos_attributes(SNUM(conn))) {
1174                         file_set_dosmode(conn, fname, new_dos_mode | aARCH, NULL);
1175                 }
1176         }
1177
1178         /*
1179          * Take care of inherited ACLs on created files - if default ACL not
1180          * selected.
1181          */
1182
1183         if (!file_existed && !def_acl) {
1184
1185                 int saved_errno = errno; /* We might get ENOSYS in the next call.. */
1186
1187                 if (SMB_VFS_FCHMOD_ACL(fsp, fsp->fd, mode) == -1 && errno == ENOSYS)
1188                         errno = saved_errno; /* Ignore ENOSYS */
1189
1190         } else if (new_mode) {
1191
1192                 int ret = -1;
1193
1194                 /* Attributes need changing. File already existed. */
1195
1196                 {
1197                         int saved_errno = errno; /* We might get ENOSYS in the next call.. */
1198                         ret = SMB_VFS_FCHMOD_ACL(fsp, fsp->fd, new_mode);
1199
1200                         if (ret == -1 && errno == ENOSYS) {
1201                                 errno = saved_errno; /* Ignore ENOSYS */
1202                         } else {
1203                                 DEBUG(5, ("open_file_shared: failed to reset attributes of file %s to 0%o\n",
1204                                         fname, (int)new_mode));
1205                                 ret = 0; /* Don't do the fchmod below. */
1206                         }
1207                 }
1208
1209                 if ((ret == -1) && (SMB_VFS_FCHMOD(fsp, fsp->fd, new_mode) == -1))
1210                         DEBUG(5, ("open_file_shared: failed to reset attributes of file %s to 0%o\n",
1211                                 fname, (int)new_mode));
1212         }
1213
1214         unlock_share_entry_fsp(fsp);
1215
1216         conn->num_files_open++;
1217
1218         return fsp;
1219 }
1220
1221 /****************************************************************************
1222  Open a file for for write to ensure that we can fchmod it.
1223 ****************************************************************************/
1224
1225 files_struct *open_file_fchmod(connection_struct *conn, const char *fname, SMB_STRUCT_STAT *psbuf)
1226 {
1227         files_struct *fsp = NULL;
1228         BOOL fsp_open;
1229
1230         if (!VALID_STAT(*psbuf))
1231                 return NULL;
1232
1233         fsp = file_new(conn);
1234         if(!fsp)
1235                 return NULL;
1236
1237         /* note! we must use a non-zero desired access or we don't get
1238            a real file descriptor. Oh what a twisted web we weave. */
1239         fsp_open = open_file(fsp,conn,fname,psbuf,O_WRONLY,0,FILE_WRITE_DATA);
1240
1241         /*
1242          * This is not a user visible file open.
1243          * Don't set a share mode and don't increment
1244          * the conn->num_files_open.
1245          */
1246
1247         if (!fsp_open) {
1248                 file_free(fsp);
1249                 return NULL;
1250         }
1251
1252         return fsp;
1253 }
1254
1255 /****************************************************************************
1256  Close the fchmod file fd - ensure no locks are lost.
1257 ****************************************************************************/
1258
1259 int close_file_fchmod(files_struct *fsp)
1260 {
1261         int ret = fd_close(fsp->conn, fsp);
1262         file_free(fsp);
1263         return ret;
1264 }
1265
1266 /****************************************************************************
1267  Open a directory from an NT SMB call.
1268 ****************************************************************************/
1269
1270 files_struct *open_directory(connection_struct *conn, char *fname, SMB_STRUCT_STAT *psbuf,
1271                         uint32 desired_access, int share_mode, int smb_ofun, int *action)
1272 {
1273         extern struct current_user current_user;
1274         BOOL got_stat = False;
1275         files_struct *fsp = file_new(conn);
1276         BOOL delete_on_close = GET_DELETE_ON_CLOSE_FLAG(share_mode);
1277
1278         if(!fsp)
1279                 return NULL;
1280
1281         if (VALID_STAT(*psbuf))
1282                 got_stat = True;
1283
1284         if (got_stat && (GET_FILE_OPEN_DISPOSITION(smb_ofun) == FILE_EXISTS_FAIL)) {
1285                 file_free(fsp);
1286                 errno = EEXIST; /* Setup so correct error is returned to client. */
1287                 return NULL;
1288         }
1289
1290         if (GET_FILE_CREATE_DISPOSITION(smb_ofun) == FILE_CREATE_IF_NOT_EXIST) {
1291
1292                 if (got_stat) {
1293
1294                         if(!S_ISDIR(psbuf->st_mode)) {
1295                                 DEBUG(0,("open_directory: %s is not a directory !\n", fname ));
1296                                 file_free(fsp);
1297                                 errno = EACCES;
1298                                 return NULL;
1299                         }
1300                         *action = FILE_WAS_OPENED;
1301
1302                 } else {
1303
1304                         /*
1305                          * Try and create the directory.
1306                          */
1307
1308                         if(!CAN_WRITE(conn)) {
1309                                 DEBUG(2,("open_directory: failing create on read-only share\n"));
1310                                 file_free(fsp);
1311                                 errno = EACCES;
1312                                 return NULL;
1313                         }
1314
1315                         if (ms_has_wild(fname))  {
1316                                 file_free(fsp);
1317                                 DEBUG(5,("open_directory: failing create on filename %s with wildcards\n", fname));
1318                                 unix_ERR_class = ERRDOS;
1319                                 unix_ERR_code = ERRinvalidname;
1320                                 unix_ERR_ntstatus = NT_STATUS_OBJECT_NAME_INVALID;
1321                                 return NULL;
1322                         }
1323
1324                         if( strchr_m(fname, ':')) {
1325                                 file_free(fsp);
1326                                 DEBUG(5,("open_directory: failing create on filename %s with colon in name\n", fname));
1327                                 unix_ERR_class = ERRDOS;
1328                                 unix_ERR_code = ERRinvalidname;
1329                                 unix_ERR_ntstatus = NT_STATUS_NOT_A_DIRECTORY;
1330                                 return NULL;
1331                         }
1332
1333                         if(vfs_MkDir(conn,fname, unix_mode(conn,aDIR, fname)) < 0) {
1334                                 DEBUG(2,("open_directory: unable to create %s. Error was %s\n",
1335                                          fname, strerror(errno) ));
1336                                 file_free(fsp);
1337                                 return NULL;
1338                         }
1339
1340                         if(SMB_VFS_STAT(conn,fname, psbuf) != 0) {
1341                                 file_free(fsp);
1342                                 return NULL;
1343                         }
1344
1345                         *action = FILE_WAS_CREATED;
1346
1347                 }
1348         } else {
1349
1350                 /*
1351                  * Don't create - just check that it *was* a directory.
1352                  */
1353
1354                 if(!got_stat) {
1355                         DEBUG(3,("open_directory: unable to stat name = %s. Error was %s\n",
1356                                  fname, strerror(errno) ));
1357                         file_free(fsp);
1358                         return NULL;
1359                 }
1360
1361                 if(!S_ISDIR(psbuf->st_mode)) {
1362                         DEBUG(0,("open_directory: %s is not a directory !\n", fname ));
1363                         file_free(fsp);
1364                         return NULL;
1365                 }
1366
1367                 *action = FILE_WAS_OPENED;
1368         }
1369
1370         DEBUG(5,("open_directory: opening directory %s\n", fname));
1371
1372         /*
1373          * Setup the files_struct for it.
1374          */
1375
1376         fsp->mode = psbuf->st_mode;
1377         fsp->inode = psbuf->st_ino;
1378         fsp->dev = psbuf->st_dev;
1379         fsp->size = psbuf->st_size;
1380         fsp->vuid = current_user.vuid;
1381         fsp->file_pid = global_smbpid;
1382         fsp->can_lock = True;
1383         fsp->can_read = False;
1384         fsp->can_write = False;
1385         fsp->share_mode = share_mode;
1386         fsp->desired_access = desired_access;
1387         fsp->print_file = False;
1388         fsp->modified = False;
1389         fsp->oplock_type = NO_OPLOCK;
1390         fsp->sent_oplock_break = NO_BREAK_SENT;
1391         fsp->is_directory = True;
1392         fsp->is_stat = False;
1393         fsp->directory_delete_on_close = False;
1394         string_set(&fsp->fsp_name,fname);
1395
1396         if (delete_on_close) {
1397                 NTSTATUS result = set_delete_on_close_internal(fsp, delete_on_close);
1398
1399                 if (NT_STATUS_V(result) !=  NT_STATUS_V(NT_STATUS_OK)) {
1400                         file_free(fsp);
1401                         return NULL;
1402                 }
1403         }
1404         conn->num_files_open++;
1405
1406         return fsp;
1407 }
1408
1409 /****************************************************************************
1410  Open a pseudo-file (no locking checks - a 'stat' open).
1411 ****************************************************************************/
1412
1413 files_struct *open_file_stat(connection_struct *conn, char *fname, SMB_STRUCT_STAT *psbuf)
1414 {
1415         extern struct current_user current_user;
1416         files_struct *fsp = NULL;
1417
1418         if (!VALID_STAT(*psbuf))
1419                 return NULL;
1420
1421         /* Can't 'stat' open directories. */
1422         if(S_ISDIR(psbuf->st_mode))
1423                 return NULL;
1424
1425         fsp = file_new(conn);
1426         if(!fsp)
1427                 return NULL;
1428
1429         DEBUG(5,("open_file_stat: 'opening' file %s\n", fname));
1430
1431         /*
1432          * Setup the files_struct for it.
1433          */
1434
1435         fsp->mode = psbuf->st_mode;
1436         /*
1437          * Don't store dev or inode, we don't want any iterator
1438          * to see this.
1439          */
1440         fsp->inode = (SMB_INO_T)0;
1441         fsp->dev = (SMB_DEV_T)0;
1442         fsp->size = psbuf->st_size;
1443         fsp->vuid = current_user.vuid;
1444         fsp->file_pid = global_smbpid;
1445         fsp->can_lock = False;
1446         fsp->can_read = False;
1447         fsp->can_write = False;
1448         fsp->share_mode = 0;
1449         fsp->desired_access = 0;
1450         fsp->print_file = False;
1451         fsp->modified = False;
1452         fsp->oplock_type = NO_OPLOCK;
1453         fsp->sent_oplock_break = NO_BREAK_SENT;
1454         fsp->is_directory = False;
1455         fsp->is_stat = True;
1456         fsp->directory_delete_on_close = False;
1457         string_set(&fsp->fsp_name,fname);
1458
1459         conn->num_files_open++;
1460
1461         return fsp;
1462 }