source3/smbd/open.c

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