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