source/smbd/open.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    file opening and share modes
   4    Copyright (C) Andrew Tridgell 1992-1998
   5    Copyright (C) Jeremy Allison 2001-2004
   6
   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|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|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         num_de_entries = get_deferred_opens(conn, dev, inode, &de_array);
 790         for (i = 0; i < num_de_entries; i++) {
 791                 deferred_open_entry *entry = &de_array[i];
 792                 if (entry->pid == mypid && entry->mid == mid && entry->dev == dev &&
 793                         entry->inode == inode) {
 794
 795                         /* Remove the deferred open entry from the array. */
 796                         delete_deferred_open_entry(entry);
 797                         SAFE_FREE(de_array);
 798                         return;
 799                 }
 800         }
 801         SAFE_FREE(de_array);
 802 }
 803
 804 /****************************************************************************
 805  Handle the 1 second delay in returning a SHARING_VIOLATION error.
 806 ****************************************************************************/
 807
 808 void defer_open_sharing_error(connection_struct *conn, struct timeval *ptv,
 809                 char *fname, SMB_DEV_T dev, SMB_INO_T inode)
 810 {
 811         uint16 mid = get_current_mid();
 812         pid_t mypid = sys_getpid();
 813         deferred_open_entry *de_array = NULL;
 814         int num_de_entries, i;
 815         struct dev_inode_bundle dib;
 816
 817         dib.dev = dev;
 818         dib.inode = inode;
 819
 820         num_de_entries = get_deferred_opens(conn, dev, inode, &de_array);
 821         for (i = 0; i < num_de_entries; i++) {
 822                 deferred_open_entry *entry = &de_array[i];
 823                 if (entry->pid == mypid && entry->mid == mid) {
 824                         /*
 825                          * Check if a 1 second timeout has expired.
 826                          */
 827                         if (usec_time_diff(ptv, &entry->time) > SHARING_VIOLATION_USEC_WAIT) {
 828                                 DEBUG(10,("defer_open_sharing_error: Deleting deferred open entry for mid %u, \
 829 file %s\n",
 830                                         (unsigned int)mid, fname ));
 831
 832                                 /* Expired, return a real error. */
 833                                 /* Remove the deferred open entry from the array. */
 834
 835                                 delete_deferred_open_entry(entry);
 836                                 SAFE_FREE(de_array);
 837                                 return;
 838                         }
 839                         /*
 840                          * If the timeout hasn't expired yet and we still have a sharing violation,
 841                          * just leave the entry in the deferred open array alone. We do need to
 842                          * reschedule this open call though (with the original created time).
 843                          */
 844                         DEBUG(10,("defer_open_sharing_error: time [%u.%06u] updating \
 845 deferred open entry for mid %u, file %s\n",
 846                                 (unsigned int)entry->time.tv_sec,
 847                                 (unsigned int)entry->time.tv_usec,
 848                                 (unsigned int)mid, fname ));
 849
 850                         push_sharing_violation_open_smb_message(&entry->time, (char *)&dib, sizeof(dib));
 851                         SAFE_FREE(de_array);
 852                         return;
 853                 }
 854         }
 855
 856         DEBUG(10,("defer_open_sharing_error: time [%u.%06u] adding deferred open entry for mid %u, file %s\n",
 857                 (unsigned int)ptv->tv_sec, (unsigned int)ptv->tv_usec, (unsigned int)mid, fname ));
 858
 859         if (!push_sharing_violation_open_smb_message(ptv, (char *)&dib, sizeof(dib))) {
 860                 SAFE_FREE(de_array);
 861                 return;
 862         }
 863         if (!add_deferred_open(mid, ptv, dev, inode, global_oplock_port, fname)) {
 864                 remove_sharing_violation_open_smb_message(mid);
 865         }
 866
 867         /*
 868          * Push the MID of this packet on the signing queue.
 869          * We only do this once, the first time we push the packet
 870          * onto the deferred open queue, as this has a side effect
 871          * of incrementing the response sequence number.
 872          */
 873
 874         srv_defer_sign_response(mid);
 875
 876         SAFE_FREE(de_array);
 877 }
 878
 879 /****************************************************************************
 880  Set a kernel flock on a file for NFS interoperability.
 881  This requires a patch to Linux.
 882 ****************************************************************************/
 883
 884 static void kernel_flock(files_struct *fsp, int deny_mode)
 885 {
 886 #if HAVE_KERNEL_SHARE_MODES
 887         int kernel_mode = 0;
 888         if (deny_mode == DENY_READ) kernel_mode = LOCK_MAND|LOCK_WRITE;
 889         else if (deny_mode == DENY_WRITE) kernel_mode = LOCK_MAND|LOCK_READ;
 890         else if (deny_mode == DENY_ALL) kernel_mode = LOCK_MAND;
 891         if (kernel_mode) flock(fsp->fd, kernel_mode);
 892 #endif
 893         ;;
 894 }
 895
 896
 897 static BOOL open_match_attributes(connection_struct *conn, const char *path, uint32 old_dos_mode, uint32 new_dos_mode,
 898                 mode_t existing_mode, mode_t new_mode, mode_t *returned_mode)
 899 {
 900         uint32 noarch_old_dos_mode, noarch_new_dos_mode;
 901
 902         noarch_old_dos_mode = (old_dos_mode & ~FILE_ATTRIBUTE_ARCHIVE);
 903         noarch_new_dos_mode = (new_dos_mode & ~FILE_ATTRIBUTE_ARCHIVE);
 904
 905         if((noarch_old_dos_mode == 0 && noarch_new_dos_mode != 0) ||
 906            (noarch_old_dos_mode != 0 && ((noarch_old_dos_mode & noarch_new_dos_mode) == noarch_old_dos_mode)))
 907                 *returned_mode = new_mode;
 908         else
 909                 *returned_mode = (mode_t)0;
 910
 911         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",
 912                 path,
 913                 old_dos_mode, (unsigned int)existing_mode, new_dos_mode, (unsigned int)*returned_mode ));
 914
 915         /* If we're mapping SYSTEM and HIDDEN ensure they match. */
 916         if (lp_map_system(SNUM(conn)) || lp_store_dos_attributes(SNUM(conn))) {
 917                 if ((old_dos_mode & FILE_ATTRIBUTE_SYSTEM) && !(new_dos_mode & FILE_ATTRIBUTE_SYSTEM))
 918                         return False;
 919         }
 920         if (lp_map_hidden(SNUM(conn)) || lp_store_dos_attributes(SNUM(conn))) {
 921                 if ((old_dos_mode & FILE_ATTRIBUTE_HIDDEN) && !(new_dos_mode & FILE_ATTRIBUTE_HIDDEN))
 922                         return False;
 923         }
 924         return True;
 925 }
 926
 927 /****************************************************************************
 928  Open a file with a share mode.
 929 ****************************************************************************/
 930
 931 files_struct *open_file_shared(connection_struct *conn,char *fname, SMB_STRUCT_STAT *psbuf,
 932                                int share_mode,int ofun, uint32 new_dos_mode, int oplock_request,
 933                                int *Access,int *action)
 934 {
 935         return open_file_shared1(conn, fname, psbuf, 0, share_mode, ofun, new_dos_mode,
 936                                  oplock_request, Access, action);
 937 }
 938
 939 /****************************************************************************
 940  Open a file with a share mode.
 941 ****************************************************************************/
 942
 943 files_struct *open_file_shared1(connection_struct *conn,char *fname, SMB_STRUCT_STAT *psbuf,
 944                                 uint32 desired_access,
 945                                 int share_mode,int ofun, uint32 new_dos_mode,
 946                                 int oplock_request,
 947                                 int *Access,int *paction)
 948 {
 949         int flags=0;
 950         int flags2=0;
 951         int deny_mode = GET_DENY_MODE(share_mode);
 952         BOOL allow_share_delete = GET_ALLOW_SHARE_DELETE(share_mode);
 953         BOOL delete_on_close = GET_DELETE_ON_CLOSE_FLAG(share_mode);
 954         BOOL file_existed = VALID_STAT(*psbuf);
 955         BOOL fcbopen = False;
 956         BOOL def_acl = False;
 957         BOOL add_share_mode = True;
 958         BOOL internal_only_open = False;
 959         SMB_DEV_T dev = 0;
 960         SMB_INO_T inode = 0;
 961         int num_share_modes = 0;
 962         BOOL all_current_opens_are_level_II = False;
 963         BOOL fsp_open = False;
 964         files_struct *fsp = NULL;
 965         int open_mode=0;
 966         uint16 port = 0;
 967         mode_t new_mode = (mode_t)0;
 968         int action;
 969         uint32 existing_dos_mode = 0;
 970         struct pending_message_list *pml = NULL;
 971         uint16 mid = get_current_mid();
 972         /* We add aARCH to this as this mode is only used if the file is created new. */
 973         mode_t mode = unix_mode(conn,new_dos_mode | aARCH,fname);
 974
 975         if (oplock_request == INTERNAL_OPEN_ONLY) {
 976                 internal_only_open = True;
 977                 oplock_request = 0;
 978         }
 979
 980         if ((pml = get_open_deferred_message(mid)) != NULL) {
 981                 struct dev_inode_bundle dib;
 982
 983                 memcpy(&dib, pml->private_data.data, sizeof(dib));
 984
 985                 /* There could be a race condition where the dev/inode pair
 986                         has changed since we deferred the message. If so, just
 987                         remove the deferred open entry and return sharing violation. */
 988
 989                 /* If the timeout value is non-zero, we need to just
 990                         return sharing violation. Don't retry the open
 991                         as we were not notified of a close and we don't want to
 992                         trigger another spurious oplock break. */
 993
 994                 if (!file_existed || dib.dev != psbuf->st_dev || dib.inode != psbuf->st_ino ||
 995                                 pml->msg_time.tv_sec || pml->msg_time.tv_usec) {
 996                         /* Ensure we don't reprocess this message. */
 997                         remove_sharing_violation_open_smb_message(mid);
 998
 999                         /* Now remove the deferred open entry under lock. */
1000                         lock_share_entry(conn, dib.dev, dib.inode);
1001                         delete_defered_open_entry_record(conn, dib.dev, dib.inode);
1002                         unlock_share_entry(conn, dib.dev, dib.inode);
1003
1004                         unix_ERR_class = ERRDOS;
1005                         unix_ERR_code = ERRbadshare;
1006                         unix_ERR_ntstatus = NT_STATUS_SHARING_VIOLATION;
1007                         return NULL;
1008                 }
1009                 /* Ensure we don't reprocess this message. */
1010                 remove_sharing_violation_open_smb_message(mid);
1011
1012         }
1013
1014         if (conn->printer) {
1015                 /* printers are handled completely differently. Most of the passed parameters are
1016                         ignored */
1017                 if (Access)
1018                         *Access = DOS_OPEN_WRONLY;
1019                 if (action)
1020                         *paction = FILE_WAS_CREATED;
1021                 return print_fsp_open(conn, fname);
1022         }
1023
1024         fsp = file_new(conn);
1025         if(!fsp)
1026                 return NULL;
1027
1028         DEBUG(10,("open_file_shared: fname = %s, dos_attrs = %x, share_mode = %x, ofun = %x, mode = %o, oplock request = %d\n",
1029                 fname, new_dos_mode, share_mode, ofun, (int)mode,  oplock_request ));
1030
1031         if (!check_name(fname,conn)) {
1032                 file_free(fsp);
1033                 return NULL;
1034         }
1035
1036         new_dos_mode &= SAMBA_ATTRIBUTES_MASK;
1037         if (file_existed) {
1038                 existing_dos_mode = dos_mode(conn, fname, psbuf);
1039         }
1040
1041         /* ignore any oplock requests if oplocks are disabled */
1042         if (!lp_oplocks(SNUM(conn)) || global_client_failed_oplock_break) {
1043                 oplock_request = 0;
1044         }
1045
1046         /* this is for OS/2 EAs - try and say we don't support them */
1047         if (strstr(fname,".+,;=[].")) {
1048                 unix_ERR_class = ERRDOS;
1049                 /* OS/2 Workplace shell fix may be main code stream in a later release. */
1050 #if 1 /* OS2_WPS_FIX - Recent versions of OS/2 need this. */
1051                 unix_ERR_code = ERRcannotopen;
1052 #else /* OS2_WPS_FIX */
1053                 unix_ERR_code = ERROR_EAS_NOT_SUPPORTED;
1054 #endif /* OS2_WPS_FIX */
1055
1056                 DEBUG(5,("open_file_shared: OS/2 EA's are not supported.\n"));
1057                 file_free(fsp);
1058                 return NULL;
1059         }
1060
1061         if ((GET_FILE_OPEN_DISPOSITION(ofun) == FILE_EXISTS_FAIL) && file_existed)  {
1062                 DEBUG(5,("open_file_shared: create new requested for file %s and file already exists.\n",
1063                         fname ));
1064                 file_free(fsp);
1065                 if (S_ISDIR(psbuf->st_mode)) {
1066                         errno = EISDIR;
1067                 } else {
1068                         errno = EEXIST;
1069                 }
1070                 return NULL;
1071         }
1072
1073         if (CAN_WRITE(conn) && (GET_FILE_CREATE_DISPOSITION(ofun) == FILE_CREATE_IF_NOT_EXIST))
1074                 flags2 |= O_CREAT;
1075
1076         if (CAN_WRITE(conn) && (GET_FILE_OPEN_DISPOSITION(ofun) == FILE_EXISTS_TRUNCATE))
1077                 flags2 |= O_TRUNC;
1078
1079         /* We only care about matching attributes on file exists and truncate. */
1080         if (file_existed && (GET_FILE_OPEN_DISPOSITION(ofun) == FILE_EXISTS_TRUNCATE)) {
1081                 if (!open_match_attributes(conn, fname, existing_dos_mode, new_dos_mode,
1082                                         psbuf->st_mode, mode, &new_mode)) {
1083                         DEBUG(5,("open_file_shared: attributes missmatch for file %s (%x %x) (0%o, 0%o)\n",
1084                                                 fname, existing_dos_mode, new_dos_mode,
1085                                                 (int)psbuf->st_mode, (int)mode ));
1086                         file_free(fsp);
1087                         errno = EACCES;
1088                         return NULL;
1089                 }
1090         }
1091
1092         if (GET_FILE_OPEN_DISPOSITION(ofun) == FILE_EXISTS_FAIL)
1093                 flags2 |= O_EXCL;
1094
1095         /* note that we ignore the append flag as
1096                 append does not mean the same thing under dos and unix */
1097
1098         switch (GET_OPEN_MODE(share_mode)) {
1099                 case DOS_OPEN_WRONLY:
1100                         flags = O_WRONLY;
1101                         if (desired_access == 0)
1102                                 desired_access = FILE_WRITE_DATA;
1103                         break;
1104                 case DOS_OPEN_FCB:
1105                         fcbopen = True;
1106                         flags = O_RDWR;
1107                         if (desired_access == 0)
1108                                 desired_access = FILE_READ_DATA|FILE_WRITE_DATA;
1109                         break;
1110                 case DOS_OPEN_RDWR:
1111                         flags = O_RDWR;
1112                         if (desired_access == 0)
1113                                 desired_access = FILE_READ_DATA|FILE_WRITE_DATA;
1114                         break;
1115                 default:
1116                         flags = O_RDONLY;
1117                         if (desired_access == 0)
1118                                 desired_access = FILE_READ_DATA;
1119                         break;
1120         }
1121
1122 #if defined(O_SYNC)
1123         if (GET_FILE_SYNC_OPENMODE(share_mode)) {
1124                 flags2 |= O_SYNC;
1125         }
1126 #endif /* O_SYNC */
1127
1128         if (flags != O_RDONLY && file_existed &&
1129                         (!CAN_WRITE(conn) || IS_DOS_READONLY(existing_dos_mode))) {
1130                 if (!fcbopen) {
1131                         DEBUG(5,("open_file_shared: read/write access requested for file %s on read only %s\n",
1132                                 fname, !CAN_WRITE(conn) ? "share" : "file" ));
1133                         file_free(fsp);
1134                         errno = EACCES;
1135                         return NULL;
1136                 }
1137                 flags = O_RDONLY;
1138         }
1139
1140         if (deny_mode > DENY_NONE && deny_mode!=DENY_FCB) {
1141                 DEBUG(2,("Invalid deny mode %d on file %s\n",deny_mode,fname));
1142                 file_free(fsp);
1143                 errno = EINVAL;
1144                 return NULL;
1145         }
1146
1147         if (desired_access && ((desired_access & ~(SYNCHRONIZE_ACCESS|FILE_READ_ATTRIBUTES|FILE_WRITE_ATTRIBUTES))==0) &&
1148                 ((desired_access & (SYNCHRONIZE_ACCESS|FILE_READ_ATTRIBUTES|FILE_WRITE_ATTRIBUTES)) != 0)) {
1149                 /* Stat open that doesn't trigger oplock breaks or share mode checks... ! JRA. */
1150                 deny_mode = DENY_NONE;
1151                 if (file_existed) {
1152                         oplock_request = 0;
1153                         add_share_mode = False;
1154                         flags2 &= ~O_CREAT;
1155                 }
1156         }
1157
1158         if (file_existed) {
1159
1160                 dev = psbuf->st_dev;
1161                 inode = psbuf->st_ino;
1162
1163                 lock_share_entry(conn, dev, inode);
1164
1165                 num_share_modes = open_mode_check(conn, fname, dev, inode,
1166                                                   desired_access,
1167                                                   share_mode,
1168                                                   &flags, &oplock_request, &all_current_opens_are_level_II);
1169                 if(num_share_modes == -1) {
1170
1171                         /*
1172                          * This next line is a subtlety we need for MS-Access. If a file open will
1173                          * fail due to share permissions and also for security (access)
1174                          * reasons, we need to return the access failed error, not the
1175                          * share error. This means we must attempt to open the file anyway
1176                          * in order to get the UNIX access error - even if we're going to
1177                          * fail the open for share reasons. This is bad, as we're burning
1178                          * another fd if there are existing locks but there's nothing else
1179                          * we can do. We also ensure we're not going to create or tuncate
1180                          * the file as we only want an access decision at this stage. JRA.
1181                          */
1182                         errno = 0;
1183                         fsp_open = open_file(fsp,conn,fname,psbuf,
1184                                                 flags|(flags2&~(O_TRUNC|O_CREAT)),mode,desired_access);
1185
1186                         DEBUG(4,("open_file_shared : share_mode deny - calling open_file with \
1187 flags=0x%X flags2=0x%X mode=0%o returned %d\n",
1188                                 flags,(flags2&~(O_TRUNC|O_CREAT)),(int)mode,(int)fsp_open ));
1189
1190                         if (!fsp_open && errno) {
1191                                 unix_ERR_class = ERRDOS;
1192                                 unix_ERR_code = ERRnoaccess;
1193                                 unix_ERR_ntstatus = NT_STATUS_ACCESS_DENIED;
1194                         }
1195
1196                         /*
1197                          * If we're returning a share violation, ensure we cope with
1198                          * the braindead 1 second delay.
1199                          */
1200
1201                         if (!internal_only_open && NT_STATUS_EQUAL(unix_ERR_ntstatus,NT_STATUS_SHARING_VIOLATION)) {
1202                                 /* The fsp->open_time here represents the current time of day. */
1203                                 defer_open_sharing_error(conn, &fsp->open_time, fname, dev, inode);
1204                         }
1205
1206                         unlock_share_entry(conn, dev, inode);
1207                         if (fsp_open) {
1208                                 fd_close(conn, fsp);
1209                                 /*
1210                                  * We have detected a sharing violation here
1211                                  * so return the correct error code
1212                                  */
1213                                 unix_ERR_class = ERRDOS;
1214                                 unix_ERR_code = ERRbadshare;
1215                                 unix_ERR_ntstatus = NT_STATUS_SHARING_VIOLATION;
1216                         }
1217                         file_free(fsp);
1218                         return NULL;
1219                 }
1220
1221                 /*
1222                  * We exit this block with the share entry *locked*.....
1223                  */
1224         }
1225
1226         /*
1227          * Ensure we pay attention to default ACLs on directories if required.
1228          */
1229
1230         if ((flags2 & O_CREAT) && lp_inherit_acls(SNUM(conn)) &&
1231                         (def_acl = directory_has_default_acl(conn, parent_dirname(fname))))
1232                 mode = 0777;
1233
1234         DEBUG(4,("calling open_file with flags=0x%X flags2=0x%X mode=0%o\n",
1235                         flags,flags2,(int)mode));
1236
1237         /*
1238          * open_file strips any O_TRUNC flags itself.
1239          */
1240
1241         fsp_open = open_file(fsp,conn,fname,psbuf,flags|flags2,mode,desired_access);
1242
1243         if (!fsp_open && (flags == O_RDWR) && (errno != ENOENT) && fcbopen) {
1244                 if((fsp_open = open_file(fsp,conn,fname,psbuf,O_RDONLY,mode,desired_access)) == True)
1245                         flags = O_RDONLY;
1246         }
1247
1248         if (!fsp_open) {
1249                 if(file_existed)
1250                         unlock_share_entry(conn, dev, inode);
1251                 file_free(fsp);
1252                 return NULL;
1253         }
1254
1255         /*
1256          * Deal with the race condition where two smbd's detect the file doesn't
1257          * exist and do the create at the same time. One of them will win and
1258          * set a share mode, the other (ie. this one) should check if the
1259          * requested share mode for this create is allowed.
1260          */
1261
1262         if (!file_existed) {
1263
1264                 /*
1265                  * Now the file exists and fsp is successfully opened,
1266                  * fsp->dev and fsp->inode are valid and should replace the
1267                  * dev=0,inode=0 from a non existent file. Spotted by
1268                  * Nadav Danieli <nadavd@exanet.com>. JRA.
1269                  */
1270
1271                 dev = fsp->dev;
1272                 inode = fsp->inode;
1273
1274                 lock_share_entry_fsp(fsp);
1275
1276                 num_share_modes = open_mode_check(conn, fname, dev, inode,
1277                                                   desired_access,
1278                                                   share_mode,
1279                                                   &flags, &oplock_request, &all_current_opens_are_level_II);
1280
1281                 if(num_share_modes == -1) {
1282                         /*
1283                          * If we're returning a share violation, ensure we cope with
1284                          * the braindead 1 second delay.
1285                          */
1286
1287                         if (!internal_only_open && NT_STATUS_EQUAL(unix_ERR_ntstatus,NT_STATUS_SHARING_VIOLATION)) {
1288                                 /* The fsp->open_time here represents the current time of day. */
1289                                 defer_open_sharing_error(conn, &fsp->open_time, fname, dev, inode);
1290                         }
1291
1292                         unlock_share_entry_fsp(fsp);
1293                         fd_close(conn,fsp);
1294                         file_free(fsp);
1295                         /*
1296                          * We have detected a sharing violation here, so
1297                          * return the correct code.
1298                          */
1299                         unix_ERR_class = ERRDOS;
1300                         unix_ERR_code = ERRbadshare;
1301                         unix_ERR_ntstatus = NT_STATUS_SHARING_VIOLATION;
1302                         return NULL;
1303                 }
1304
1305                 /*
1306                  * If there are any share modes set then the file *did*
1307                  * exist. Ensure we return the correct value for action.
1308                  */
1309
1310                 if (num_share_modes > 0)
1311                         file_existed = True;
1312
1313                 /*
1314                  * We exit this block with the share entry *locked*.....
1315                  */
1316         }
1317
1318         /* note that we ignore failure for the following. It is
1319            basically a hack for NFS, and NFS will never set one of
1320            these only read them. Nobody but Samba can ever set a deny
1321            mode and we have already checked our more authoritative
1322            locking database for permission to set this deny mode. If
1323            the kernel refuses the operations then the kernel is wrong */
1324         kernel_flock(fsp, deny_mode);
1325
1326         /*
1327          * At this point onwards, we can guarentee that the share entry
1328          * is locked, whether we created the file or not, and that the
1329          * deny mode is compatible with all current opens.
1330          */
1331
1332         /*
1333          * If requested, truncate the file.
1334          */
1335
1336         if (flags2&O_TRUNC) {
1337                 /*
1338                  * We are modifing the file after open - update the stat struct..
1339                  */
1340                 if ((SMB_VFS_FTRUNCATE(fsp,fsp->fd,0) == -1) || (SMB_VFS_FSTAT(fsp,fsp->fd,psbuf)==-1)) {
1341                         unlock_share_entry_fsp(fsp);
1342                         fd_close(conn,fsp);
1343                         file_free(fsp);
1344                         return NULL;
1345                 }
1346         }
1347
1348         switch (flags) {
1349                 case O_RDONLY:
1350                         open_mode = DOS_OPEN_RDONLY;
1351                         break;
1352                 case O_RDWR:
1353                         open_mode = DOS_OPEN_RDWR;
1354                         break;
1355                 case O_WRONLY:
1356                         open_mode = DOS_OPEN_WRONLY;
1357                         break;
1358         }
1359
1360         fsp->share_mode = SET_DENY_MODE(deny_mode) |
1361                                                 SET_OPEN_MODE(open_mode) |
1362                                                 SET_ALLOW_SHARE_DELETE(allow_share_delete);
1363
1364         DEBUG(10,("open_file_shared : share_mode = %x\n", fsp->share_mode ));
1365
1366         if (Access) {
1367                 (*Access) = open_mode;
1368         }
1369
1370         if (file_existed && !(flags2 & O_TRUNC))
1371                 action = FILE_WAS_OPENED;
1372         if (file_existed && (flags2 & O_TRUNC))
1373                 action = FILE_WAS_OVERWRITTEN;
1374         if (!file_existed)
1375                 action = FILE_WAS_CREATED;
1376
1377         if (paction) {
1378                 *paction = action;
1379         }
1380
1381         /*
1382          * Setup the oplock info in both the shared memory and
1383          * file structs.
1384          */
1385
1386         if(oplock_request && (num_share_modes == 0) &&
1387                         !IS_VETO_OPLOCK_PATH(conn,fname) && set_file_oplock(fsp, oplock_request) ) {
1388                 port = global_oplock_port;
1389         } else if (oplock_request && all_current_opens_are_level_II) {
1390                 port = global_oplock_port;
1391                 oplock_request = LEVEL_II_OPLOCK;
1392                 set_file_oplock(fsp, oplock_request);
1393         } else {
1394                 port = 0;
1395                 oplock_request = 0;
1396         }
1397
1398         if (add_share_mode) {
1399                 set_share_mode(fsp, port, oplock_request);
1400         }
1401
1402         if (delete_on_close) {
1403                 NTSTATUS result = set_delete_on_close_internal(fsp, delete_on_close);
1404
1405                 if (NT_STATUS_V(result) !=  NT_STATUS_V(NT_STATUS_OK)) {
1406                         /* Remember to delete the mode we just added. */
1407                         if (add_share_mode) {
1408                                 del_share_mode(fsp, NULL);
1409                         }
1410                         unlock_share_entry_fsp(fsp);
1411                         fd_close(conn,fsp);
1412                         file_free(fsp);
1413                         return NULL;
1414                 }
1415         }
1416
1417         if (action == FILE_WAS_OVERWRITTEN || action == FILE_WAS_CREATED) {
1418                 /* Files should be initially set as archive */
1419                 if (lp_map_archive(SNUM(conn)) || lp_store_dos_attributes(SNUM(conn))) {
1420                         file_set_dosmode(conn, fname, new_dos_mode | aARCH, NULL);
1421                 }
1422         }
1423
1424         /*
1425          * Take care of inherited ACLs on created files - if default ACL not
1426          * selected.
1427          */
1428
1429         if (!file_existed && !def_acl) {
1430
1431                 int saved_errno = errno; /* We might get ENOSYS in the next call.. */
1432
1433                 if (SMB_VFS_FCHMOD_ACL(fsp, fsp->fd, mode) == -1 && errno == ENOSYS)
1434                         errno = saved_errno; /* Ignore ENOSYS */
1435
1436         } else if (new_mode) {
1437
1438                 int ret = -1;
1439
1440                 /* Attributes need changing. File already existed. */
1441
1442                 {
1443                         int saved_errno = errno; /* We might get ENOSYS in the next call.. */
1444                         ret = SMB_VFS_FCHMOD_ACL(fsp, fsp->fd, new_mode);
1445
1446                         if (ret == -1 && errno == ENOSYS) {
1447                                 errno = saved_errno; /* Ignore ENOSYS */
1448                         } else {
1449                                 DEBUG(5, ("open_file_shared: failed to reset attributes of file %s to 0%o\n",
1450                                         fname, (int)new_mode));
1451                                 ret = 0; /* Don't do the fchmod below. */
1452                         }
1453                 }
1454
1455                 if ((ret == -1) && (SMB_VFS_FCHMOD(fsp, fsp->fd, new_mode) == -1))
1456                         DEBUG(5, ("open_file_shared: failed to reset attributes of file %s to 0%o\n",
1457                                 fname, (int)new_mode));
1458         }
1459
1460         /* If this is a successful open, we must remove any deferred open records. */
1461         delete_defered_open_entry_record(conn, fsp->dev, fsp->inode);
1462         unlock_share_entry_fsp(fsp);
1463
1464         conn->num_files_open++;
1465
1466         return fsp;
1467 }
1468
1469 /****************************************************************************
1470  Open a file for for write to ensure that we can fchmod it.
1471 ****************************************************************************/
1472
1473 files_struct *open_file_fchmod(connection_struct *conn, const char *fname, SMB_STRUCT_STAT *psbuf)
1474 {
1475         files_struct *fsp = NULL;
1476         BOOL fsp_open;
1477
1478         if (!VALID_STAT(*psbuf))
1479                 return NULL;
1480
1481         fsp = file_new(conn);
1482         if(!fsp)
1483                 return NULL;
1484
1485         /* note! we must use a non-zero desired access or we don't get
1486            a real file descriptor. Oh what a twisted web we weave. */
1487         fsp_open = open_file(fsp,conn,fname,psbuf,O_WRONLY,0,FILE_WRITE_DATA);
1488
1489         /*
1490          * This is not a user visible file open.
1491          * Don't set a share mode and don't increment
1492          * the conn->num_files_open.
1493          */
1494
1495         if (!fsp_open) {
1496                 file_free(fsp);
1497                 return NULL;
1498         }
1499
1500         return fsp;
1501 }
1502
1503 /****************************************************************************
1504  Close the fchmod file fd - ensure no locks are lost.
1505 ****************************************************************************/
1506
1507 int close_file_fchmod(files_struct *fsp)
1508 {
1509         int ret = fd_close(fsp->conn, fsp);
1510         file_free(fsp);
1511         return ret;
1512 }
1513
1514 /****************************************************************************
1515  Open a directory from an NT SMB call.
1516 ****************************************************************************/
1517
1518 files_struct *open_directory(connection_struct *conn, char *fname, SMB_STRUCT_STAT *psbuf,
1519                         uint32 desired_access, int share_mode, int smb_ofun, int *action)
1520 {
1521         extern struct current_user current_user;
1522         BOOL got_stat = False;
1523         files_struct *fsp = file_new(conn);
1524         BOOL delete_on_close = GET_DELETE_ON_CLOSE_FLAG(share_mode);
1525
1526         if(!fsp)
1527                 return NULL;
1528
1529         if (VALID_STAT(*psbuf))
1530                 got_stat = True;
1531
1532         if (got_stat && (GET_FILE_OPEN_DISPOSITION(smb_ofun) == FILE_EXISTS_FAIL)) {
1533                 file_free(fsp);
1534                 errno = EEXIST; /* Setup so correct error is returned to client. */
1535                 return NULL;
1536         }
1537
1538         if (GET_FILE_CREATE_DISPOSITION(smb_ofun) == FILE_CREATE_IF_NOT_EXIST) {
1539
1540                 if (got_stat) {
1541
1542                         if(!S_ISDIR(psbuf->st_mode)) {
1543                                 DEBUG(0,("open_directory: %s is not a directory !\n", fname ));
1544                                 file_free(fsp);
1545                                 errno = EACCES;
1546                                 return NULL;
1547                         }
1548                         *action = FILE_WAS_OPENED;
1549
1550                 } else {
1551
1552                         /*
1553                          * Try and create the directory.
1554                          */
1555
1556                         if(!CAN_WRITE(conn)) {
1557                                 DEBUG(2,("open_directory: failing create on read-only share\n"));
1558                                 file_free(fsp);
1559                                 errno = EACCES;
1560                                 return NULL;
1561                         }
1562
1563                         if (ms_has_wild(fname))  {
1564                                 file_free(fsp);
1565                                 DEBUG(5,("open_directory: failing create on filename %s with wildcards\n", fname));
1566                                 unix_ERR_class = ERRDOS;
1567                                 unix_ERR_code = ERRinvalidname;
1568                                 unix_ERR_ntstatus = NT_STATUS_OBJECT_NAME_INVALID;
1569                                 return NULL;
1570                         }
1571
1572                         if( strchr_m(fname, ':')) {
1573                                 file_free(fsp);
1574                                 DEBUG(5,("open_directory: failing create on filename %s with colon in name\n", fname));
1575                                 unix_ERR_class = ERRDOS;
1576                                 unix_ERR_code = ERRinvalidname;
1577                                 unix_ERR_ntstatus = NT_STATUS_NOT_A_DIRECTORY;
1578                                 return NULL;
1579                         }
1580
1581                         if(vfs_MkDir(conn,fname, unix_mode(conn,aDIR, fname)) < 0) {
1582                                 DEBUG(2,("open_directory: unable to create %s. Error was %s\n",
1583                                          fname, strerror(errno) ));
1584                                 file_free(fsp);
1585                                 return NULL;
1586                         }
1587
1588                         if(SMB_VFS_STAT(conn,fname, psbuf) != 0) {
1589                                 file_free(fsp);
1590                                 return NULL;
1591                         }
1592
1593                         *action = FILE_WAS_CREATED;
1594
1595                 }
1596         } else {
1597
1598                 /*
1599                  * Don't create - just check that it *was* a directory.
1600                  */
1601
1602                 if(!got_stat) {
1603                         DEBUG(3,("open_directory: unable to stat name = %s. Error was %s\n",
1604                                  fname, strerror(errno) ));
1605                         file_free(fsp);
1606                         return NULL;
1607                 }
1608
1609                 if(!S_ISDIR(psbuf->st_mode)) {
1610                         DEBUG(0,("open_directory: %s is not a directory !\n", fname ));
1611                         file_free(fsp);
1612                         return NULL;
1613                 }
1614
1615                 *action = FILE_WAS_OPENED;
1616         }
1617
1618         DEBUG(5,("open_directory: opening directory %s\n", fname));
1619
1620         /*
1621          * Setup the files_struct for it.
1622          */
1623
1624         fsp->mode = psbuf->st_mode;
1625         fsp->inode = psbuf->st_ino;
1626         fsp->dev = psbuf->st_dev;
1627         fsp->size = psbuf->st_size;
1628         fsp->vuid = current_user.vuid;
1629         fsp->file_pid = global_smbpid;
1630         fsp->can_lock = True;
1631         fsp->can_read = False;
1632         fsp->can_write = False;
1633         fsp->share_mode = share_mode;
1634         fsp->desired_access = desired_access;
1635         fsp->print_file = False;
1636         fsp->modified = False;
1637         fsp->oplock_type = NO_OPLOCK;
1638         fsp->sent_oplock_break = NO_BREAK_SENT;
1639         fsp->is_directory = True;
1640         fsp->is_stat = False;
1641         fsp->directory_delete_on_close = False;
1642         string_set(&fsp->fsp_name,fname);
1643
1644         if (delete_on_close) {
1645                 NTSTATUS result = set_delete_on_close_internal(fsp, delete_on_close);
1646
1647                 if (NT_STATUS_V(result) !=  NT_STATUS_V(NT_STATUS_OK)) {
1648                         file_free(fsp);
1649                         return NULL;
1650                 }
1651         }
1652         conn->num_files_open++;
1653
1654         return fsp;
1655 }
1656
1657 /****************************************************************************
1658  Open a pseudo-file (no locking checks - a 'stat' open).
1659 ****************************************************************************/
1660
1661 files_struct *open_file_stat(connection_struct *conn, char *fname, SMB_STRUCT_STAT *psbuf)
1662 {
1663         extern struct current_user current_user;
1664         files_struct *fsp = NULL;
1665
1666         if (!VALID_STAT(*psbuf))
1667                 return NULL;
1668
1669         /* Can't 'stat' open directories. */
1670         if(S_ISDIR(psbuf->st_mode))
1671                 return NULL;
1672
1673         fsp = file_new(conn);
1674         if(!fsp)
1675                 return NULL;
1676
1677         DEBUG(5,("open_file_stat: 'opening' file %s\n", fname));
1678
1679         /*
1680          * Setup the files_struct for it.
1681          */
1682
1683         fsp->mode = psbuf->st_mode;
1684         fsp->inode = psbuf->st_ino;
1685         fsp->dev = psbuf->st_dev;
1686         fsp->size = psbuf->st_size;
1687         fsp->vuid = current_user.vuid;
1688         fsp->file_pid = global_smbpid;
1689         fsp->can_lock = False;
1690         fsp->can_read = False;
1691         fsp->can_write = False;
1692         fsp->share_mode = 0;
1693         fsp->desired_access = 0;
1694         fsp->print_file = False;
1695         fsp->modified = False;
1696         fsp->oplock_type = NO_OPLOCK;
1697         fsp->sent_oplock_break = NO_BREAK_SENT;
1698         fsp->is_directory = False;
1699         fsp->is_stat = True;
1700         fsp->directory_delete_on_close = False;
1701         string_set(&fsp->fsp_name,fname);
1702
1703         conn->num_files_open++;
1704
1705         return fsp;
1706 }