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