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