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, int share_mode, int *p_flags, int *p_oplock_request,
 441                                                         BOOL *p_all_current_opens_are_level_II)
 442 {
 443         int i;
 444         int num_share_modes;
 445         int oplock_contention_count = 0;
 446         share_mode_entry *old_shares = 0;
 447         BOOL fcbopen = False;
 448         BOOL broke_oplock;
 449
 450         if(GET_OPEN_MODE(share_mode) == DOS_OPEN_FCB)
 451                 fcbopen = True;
 452
 453         num_share_modes = get_share_modes(conn, dev, inode, &old_shares);
 454
 455         if(num_share_modes == 0)
 456                 return 0;
 457
 458         /*
 459          * Check if the share modes will give us access.
 460          */
 461
 462         do {
 463                 share_mode_entry broken_entry;
 464
 465                 broke_oplock = False;
 466                 *p_all_current_opens_are_level_II = True;
 467
 468                 for(i = 0; i < num_share_modes; i++) {
 469                         share_mode_entry *share_entry = &old_shares[i];
 470
 471                         /*
 472                          * By observation of NetBench, oplocks are broken *before* share
 473                          * modes are checked. This allows a file to be closed by the client
 474                          * if the share mode would deny access and the client has an oplock.
 475                          * Check if someone has an oplock on this file. If so we must break
 476                          * it before continuing.
 477                          */
 478
 479                         if((*p_oplock_request && EXCLUSIVE_OPLOCK_TYPE(share_entry->op_type)) ||
 480                            (!*p_oplock_request && (share_entry->op_type != NO_OPLOCK))) {
 481
 482                                 BOOL opb_ret;
 483
 484                                 DEBUG(5,("open_mode_check: oplock_request = %d, breaking oplock (%x) on file %s, \
 485 dev = %x, inode = %.0f\n", *p_oplock_request, share_entry->op_type, fname, (unsigned int)dev, (double)inode));
 486
 487                                 /* Oplock break - unlock to request it. */
 488                                 unlock_share_entry(conn, dev, inode);
 489
 490                                 opb_ret = request_oplock_break(share_entry);
 491
 492                                 /* Now relock. */
 493                                 lock_share_entry(conn, dev, inode);
 494
 495                                 if(opb_ret == False) {
 496                                         DEBUG(0,("open_mode_check: FAILED when breaking oplock (%x) on file %s, \
 497 dev = %x, inode = %.0f\n", old_shares[i].op_type, fname, (unsigned int)dev, (double)inode));
 498                                         SAFE_FREE(old_shares);
 499                                         errno = EACCES;
 500                                         unix_ERR_class = ERRDOS;
 501                                         unix_ERR_code = ERRbadshare;
 502                                         return -1;
 503                                 }
 504
 505                                 broke_oplock = True;
 506                                 broken_entry = *share_entry;
 507                                 break;
 508
 509                         } else if (!LEVEL_II_OPLOCK_TYPE(share_entry->op_type)) {
 510                                 *p_all_current_opens_are_level_II = False;
 511                         }
 512
 513                         /* someone else has a share lock on it, check to see
 514                            if we can too */
 515
 516                         if(check_share_mode(conn, share_entry, share_mode, fname, fcbopen, p_flags) == False) {
 517                                 SAFE_FREE(old_shares);
 518                                 errno = EACCES;
 519                                 return -1;
 520                         }
 521
 522                 } /* end for */
 523
 524                 if(broke_oplock) {
 525                         SAFE_FREE(old_shares);
 526                         num_share_modes = get_share_modes(conn, dev, inode, &old_shares);
 527                         oplock_contention_count++;
 528
 529                         /* Paranoia check that this is no longer an exlusive entry. */
 530                         for(i = 0; i < num_share_modes; i++) {
 531                                 share_mode_entry *share_entry = &old_shares[i];
 532
 533                                 if (share_modes_identical(&broken_entry, share_entry) &&
 534                                     EXCLUSIVE_OPLOCK_TYPE(share_entry->op_type) ) {
 535
 536                                         /*
 537                                          * This should not happen. The target left this oplock
 538                                          * as exlusive.... The process *must* be dead....
 539                                          */
 540
 541                                         DEBUG(0,("open_mode_check: exlusive oplock left by process %d after break ! For file %s, \
 542 dev = %x, inode = %.0f. Deleting it to continue...\n", (int)broken_entry.pid, fname, (unsigned int)dev, (double)inode));
 543
 544                                         if (process_exists(broken_entry.pid)) {
 545                                                 DEBUG(0,("open_mode_check: Existent process %d left active oplock.\n",
 546                                                          broken_entry.pid ));
 547                                         }
 548
 549                                         if (del_share_entry(dev, inode, &broken_entry, NULL) == -1) {
 550                                                 errno = EACCES;
 551                                                 unix_ERR_class = ERRDOS;
 552                                                 unix_ERR_code = ERRbadshare;
 553                                                 return -1;
 554                                         }
 555
 556                                         /*
 557                                          * We must reload the share modes after deleting the
 558                                          * other process's entry.
 559                                          */
 560
 561                                         SAFE_FREE(old_shares);
 562                                         num_share_modes = get_share_modes(conn, dev, inode, &old_shares);
 563                                         break;
 564                                 }
 565                         } /* end for paranoia... */
 566                 } /* end if broke_oplock */
 567
 568         } while(broke_oplock);
 569
 570         if(old_shares != 0)
 571                 SAFE_FREE(old_shares);
 572
 573         /*
 574          * Refuse to grant an oplock in case the contention limit is
 575          * reached when going through the lock list multiple times.
 576          */
 577
 578         if(oplock_contention_count >= lp_oplock_contention_limit(SNUM(conn))) {
 579                 *p_oplock_request = 0;
 580                 DEBUG(4,("open_mode_check: oplock contention = %d. Not granting oplock.\n",
 581                          oplock_contention_count ));
 582         }
 583
 584         return num_share_modes;
 585 }
 586
 587 /****************************************************************************
 588 set a kernel flock on a file for NFS interoperability
 589 this requires a patch to Linux
 590 ****************************************************************************/
 591 static void kernel_flock(files_struct *fsp, int deny_mode)
 592 {
 593 #if HAVE_KERNEL_SHARE_MODES
 594         int kernel_mode = 0;
 595         if (deny_mode == DENY_READ) kernel_mode = LOCK_MAND|LOCK_WRITE;
 596         else if (deny_mode == DENY_WRITE) kernel_mode = LOCK_MAND|LOCK_READ;
 597         else if (deny_mode == DENY_ALL) kernel_mode = LOCK_MAND;
 598         if (kernel_mode) flock(fsp->fd, kernel_mode);
 599 #endif
 600         ;;
 601 }
 602
 603
 604 /****************************************************************************
 605  Open a file with a share mode. On output from this open we are guarenteeing
 606  that
 607 ****************************************************************************/
 608 files_struct *open_file_shared(connection_struct *conn,char *fname, SMB_STRUCT_STAT *psbuf,
 609                                int share_mode,int ofun, mode_t mode,int oplock_request,
 610                                int *Access,int *action)
 611 {
 612         int flags=0;
 613         int flags2=0;
 614         int deny_mode = GET_DENY_MODE(share_mode);
 615         BOOL allow_share_delete = GET_ALLOW_SHARE_DELETE(share_mode);
 616         BOOL delete_access_requested = GET_DELETE_ACCESS_REQUESTED(share_mode);
 617         BOOL delete_on_close = GET_DELETE_ON_CLOSE_FLAG(share_mode);
 618         BOOL file_existed = VALID_STAT(*psbuf);
 619         BOOL fcbopen = False;
 620         SMB_DEV_T dev = 0;
 621         SMB_INO_T inode = 0;
 622         int num_share_modes = 0;
 623         BOOL all_current_opens_are_level_II = False;
 624         BOOL fsp_open = False;
 625         files_struct *fsp = NULL;
 626         int open_mode=0;
 627         uint16 port = 0;
 628
 629         if (conn->printer) {
 630                 /* printers are handled completely differently. Most of the passed parameters are
 631                         ignored */
 632                 if (Access)
 633                         *Access = DOS_OPEN_WRONLY;
 634                 if (action)
 635                         *action = FILE_WAS_CREATED;
 636                 return print_fsp_open(conn, fname);
 637         }
 638
 639         fsp = file_new(conn);
 640         if(!fsp)
 641                 return NULL;
 642
 643         DEBUG(10,("open_file_shared: fname = %s, share_mode = %x, ofun = %x, mode = %o, oplock request = %d\n",
 644                 fname, share_mode, ofun, (int)mode,  oplock_request ));
 645
 646         if (!check_name(fname,conn)) {
 647                 file_free(fsp);
 648                 return NULL;
 649         }
 650
 651         /* ignore any oplock requests if oplocks are disabled */
 652         if (!lp_oplocks(SNUM(conn)) || global_client_failed_oplock_break) {
 653                 oplock_request = 0;
 654         }
 655
 656         /* this is for OS/2 EAs - try and say we don't support them */
 657         if (strstr(fname,".+,;=[].")) {
 658                 unix_ERR_class = ERRDOS;
 659                 /* OS/2 Workplace shell fix may be main code stream in a later release. */
 660 #if 1 /* OS2_WPS_FIX - Recent versions of OS/2 need this. */
 661                 unix_ERR_code = ERRcannotopen;
 662 #else /* OS2_WPS_FIX */
 663                 unix_ERR_code = ERROR_EAS_NOT_SUPPORTED;
 664 #endif /* OS2_WPS_FIX */
 665
 666                 DEBUG(5,("open_file_shared: OS/2 EA's are not supported.\n"));
 667                 file_free(fsp);
 668                 return NULL;
 669         }
 670
 671         if ((GET_FILE_OPEN_DISPOSITION(ofun) == FILE_EXISTS_FAIL) && file_existed)  {
 672                 DEBUG(5,("open_file_shared: create new requested for file %s and file already exists.\n",
 673                         fname ));
 674                 file_free(fsp);
 675                 errno = EEXIST;
 676                 return NULL;
 677         }
 678
 679         if (CAN_WRITE(conn) && (GET_FILE_CREATE_DISPOSITION(ofun) == FILE_CREATE_IF_NOT_EXIST))
 680                 flags2 |= O_CREAT;
 681
 682         if (CAN_WRITE(conn) && (GET_FILE_OPEN_DISPOSITION(ofun) == FILE_EXISTS_TRUNCATE))
 683                 flags2 |= O_TRUNC;
 684
 685         if (GET_FILE_OPEN_DISPOSITION(ofun) == FILE_EXISTS_FAIL)
 686                 flags2 |= O_EXCL;
 687
 688         /* note that we ignore the append flag as
 689                 append does not mean the same thing under dos and unix */
 690
 691         switch (GET_OPEN_MODE(share_mode)) {
 692                 case DOS_OPEN_WRONLY:
 693                         flags = O_WRONLY;
 694                         break;
 695                 case DOS_OPEN_FCB:
 696                         fcbopen = True;
 697                         flags = O_RDWR;
 698                         break;
 699                 case DOS_OPEN_RDWR:
 700                         flags = O_RDWR;
 701                         break;
 702                 default:
 703                         flags = O_RDONLY;
 704                         break;
 705         }
 706
 707 #if defined(O_SYNC)
 708         if (GET_FILE_SYNC_OPENMODE(share_mode)) {
 709                 flags2 |= O_SYNC;
 710         }
 711 #endif /* O_SYNC */
 712
 713         if (flags != O_RDONLY && file_existed &&
 714                         (!CAN_WRITE(conn) || IS_DOS_READONLY(dos_mode(conn,fname,psbuf)))) {
 715                 if (!fcbopen) {
 716                         DEBUG(5,("open_file_shared: read/write access requested for file %s on read only %s\n",
 717                                 fname, !CAN_WRITE(conn) ? "share" : "file" ));
 718                         file_free(fsp);
 719                         errno = EACCES;
 720                         return NULL;
 721                 }
 722                 flags = O_RDONLY;
 723         }
 724
 725         if (deny_mode > DENY_NONE && deny_mode!=DENY_FCB) {
 726                 DEBUG(2,("Invalid deny mode %d on file %s\n",deny_mode,fname));
 727                 file_free(fsp);
 728                 errno = EINVAL;
 729                 return NULL;
 730         }
 731
 732         if (file_existed) {
 733
 734                 dev = psbuf->st_dev;
 735                 inode = psbuf->st_ino;
 736
 737                 lock_share_entry(conn, dev, inode);
 738
 739                 num_share_modes = open_mode_check(conn, fname, dev, inode, share_mode,
 740                                                                 &flags, &oplock_request, &all_current_opens_are_level_II);
 741                 if(num_share_modes == -1) {
 742
 743                         /*
 744                          * This next line is a subtlety we need for MS-Access. If a file open will
 745                          * fail due to share permissions and also for security (access)
 746                          * reasons, we need to return the access failed error, not the
 747                          * share error. This means we must attempt to open the file anyway
 748                          * in order to get the UNIX access error - even if we're going to
 749                          * fail the open for share reasons. This is bad, as we're burning
 750                          * another fd if there are existing locks but there's nothing else
 751                          * we can do. We also ensure we're not going to create or tuncate
 752                          * the file as we only want an access decision at this stage. JRA.
 753                          */
 754                         fsp_open = open_file(fsp,conn,fname,psbuf,flags|(flags2&~(O_TRUNC|O_CREAT)),mode);
 755
 756                         DEBUG(4,("open_file_shared : share_mode deny - calling open_file with \
 757 flags=0x%X flags2=0x%X mode=0%o returned %d\n",
 758                                 flags,(flags2&~(O_TRUNC|O_CREAT)),(int)mode,(int)fsp_open ));
 759
 760                         unlock_share_entry(conn, dev, inode);
 761                         if (fsp_open)
 762                                 fd_close(conn, fsp);
 763                         file_free(fsp);
 764                         return NULL;
 765                 }
 766
 767                 /*
 768                  * We exit this block with the share entry *locked*.....
 769                  */
 770         }
 771
 772         DEBUG(4,("calling open_file with flags=0x%X flags2=0x%X mode=0%o\n",
 773                         flags,flags2,(int)mode));
 774
 775         /*
 776          * open_file strips any O_TRUNC flags itself.
 777          */
 778
 779         fsp_open = open_file(fsp,conn,fname,psbuf,flags|flags2,mode);
 780
 781         if (!fsp_open && (flags == O_RDWR) && (errno != ENOENT) && fcbopen) {
 782                 if((fsp_open = open_file(fsp,conn,fname,psbuf,O_RDONLY,mode)) == True)
 783                         flags = O_RDONLY;
 784         }
 785
 786         if (!fsp_open) {
 787                 if(file_existed)
 788                         unlock_share_entry(conn, dev, inode);
 789                 file_free(fsp);
 790                 return NULL;
 791         }
 792
 793         /*
 794          * Deal with the race condition where two smbd's detect the file doesn't
 795          * exist and do the create at the same time. One of them will win and
 796          * set a share mode, the other (ie. this one) should check if the
 797          * requested share mode for this create is allowed.
 798          */
 799
 800         if (!file_existed) {
 801
 802                 lock_share_entry_fsp(fsp);
 803
 804                 num_share_modes = open_mode_check(conn, fname, dev, inode, share_mode,
 805                                                                 &flags, &oplock_request, &all_current_opens_are_level_II);
 806
 807                 if(num_share_modes == -1) {
 808                         unlock_share_entry_fsp(fsp);
 809                         fd_close(conn,fsp);
 810                         file_free(fsp);
 811                         return NULL;
 812                 }
 813
 814                 /*
 815                  * If there are any share modes set then the file *did*
 816                  * exist. Ensure we return the correct value for action.
 817                  */
 818
 819                 if (num_share_modes > 0)
 820                         file_existed = True;
 821
 822                 /*
 823                  * We exit this block with the share entry *locked*.....
 824                  */
 825         }
 826
 827         /* note that we ignore failure for the following. It is
 828            basically a hack for NFS, and NFS will never set one of
 829            these only read them. Nobody but Samba can ever set a deny
 830            mode and we have already checked our more authoritative
 831            locking database for permission to set this deny mode. If
 832            the kernel refuses the operations then the kernel is wrong */
 833         kernel_flock(fsp, deny_mode);
 834
 835         /*
 836          * At this point onwards, we can guarentee that the share entry
 837          * is locked, whether we created the file or not, and that the
 838          * deny mode is compatible with all current opens.
 839          */
 840
 841         /*
 842          * If requested, truncate the file.
 843          */
 844
 845         if (flags2&O_TRUNC) {
 846                 /*
 847                  * We are modifing the file after open - update the stat struct..
 848                  */
 849                 if ((truncate_unless_locked(conn,fsp) == -1) || (vfs_fstat(fsp,fsp->fd,psbuf)==-1)) {
 850                         unlock_share_entry_fsp(fsp);
 851                         fd_close(conn,fsp);
 852                         file_free(fsp);
 853                         return NULL;
 854                 }
 855         }
 856
 857         switch (flags) {
 858                 case O_RDONLY:
 859                         open_mode = DOS_OPEN_RDONLY;
 860                         break;
 861                 case O_RDWR:
 862                         open_mode = DOS_OPEN_RDWR;
 863                         break;
 864                 case O_WRONLY:
 865                         open_mode = DOS_OPEN_WRONLY;
 866                         break;
 867         }
 868
 869         fsp->share_mode = SET_DENY_MODE(deny_mode) |
 870                                                 SET_OPEN_MODE(open_mode) |
 871                                                 SET_ALLOW_SHARE_DELETE(allow_share_delete) |
 872                                                 SET_DELETE_ACCESS_REQUESTED(delete_access_requested);
 873
 874         DEBUG(10,("open_file_shared : share_mode = %x\n", fsp->share_mode ));
 875
 876         if (Access)
 877                 (*Access) = open_mode;
 878
 879         if (action) {
 880                 if (file_existed && !(flags2 & O_TRUNC))
 881                         *action = FILE_WAS_OPENED;
 882                 if (!file_existed)
 883                         *action = FILE_WAS_CREATED;
 884                 if (file_existed && (flags2 & O_TRUNC))
 885                         *action = FILE_WAS_OVERWRITTEN;
 886         }
 887
 888         /*
 889          * Setup the oplock info in both the shared memory and
 890          * file structs.
 891          */
 892
 893         if(oplock_request && (num_share_modes == 0) &&
 894                         !IS_VETO_OPLOCK_PATH(conn,fname) && set_file_oplock(fsp, oplock_request) ) {
 895                 port = global_oplock_port;
 896         } else if (oplock_request && all_current_opens_are_level_II) {
 897                 port = global_oplock_port;
 898                 oplock_request = LEVEL_II_OPLOCK;
 899                 set_file_oplock(fsp, oplock_request);
 900         } else {
 901                 port = 0;
 902                 oplock_request = 0;
 903         }
 904
 905         set_share_mode(fsp, port, oplock_request);
 906
 907         if (delete_on_close) {
 908                 NTSTATUS result = set_delete_on_close_internal(fsp, delete_on_close);
 909
 910                 if (NT_STATUS_V(result) !=  NT_STATUS_V(NT_STATUS_OK)) {
 911                         unlock_share_entry_fsp(fsp);
 912                         fd_close(conn,fsp);
 913                         file_free(fsp);
 914                         return NULL;
 915                 }
 916         }
 917
 918         /*
 919          * Take care of inherited ACLs on created files. JRA.
 920          */
 921
 922         if (!file_existed && (conn->vfs_ops.fchmod_acl != NULL)) {
 923                 int saved_errno = errno; /* We might get ENOSYS in the next call.. */
 924                 if (conn->vfs_ops.fchmod_acl(fsp, fsp->fd, mode) == -1 && errno == ENOSYS)
 925                         errno = saved_errno; /* Ignore ENOSYS */
 926         }
 927
 928         unlock_share_entry_fsp(fsp);
 929
 930         conn->num_files_open++;
 931
 932         return fsp;
 933 }
 934
 935 /****************************************************************************
 936  Open a file for permissions read only. Return a pseudo file entry
 937  with the 'stat_open' flag set
 938 ****************************************************************************/
 939
 940 files_struct *open_file_stat(connection_struct *conn, char *fname,
 941                                                         SMB_STRUCT_STAT *psbuf, int smb_ofun, int *action)
 942 {
 943         extern struct current_user current_user;
 944         files_struct *fsp = NULL;
 945
 946         if (!VALID_STAT(*psbuf)) {
 947                 DEBUG(0,("open_file_stat: unable to stat name = %s. Error was %s\n", fname, strerror(errno) ));
 948                 return NULL;
 949         }
 950
 951         if(S_ISDIR(psbuf->st_mode)) {
 952                 DEBUG(0,("open_file_stat: %s is a directory !\n", fname ));
 953                 return NULL;
 954         }
 955
 956         fsp = file_new(conn);
 957         if(!fsp)
 958                 return NULL;
 959
 960         *action = FILE_WAS_OPENED;
 961
 962         DEBUG(5,("open_file_stat: opening file %s as a stat entry\n", fname));
 963
 964         /*
 965          * Setup the files_struct for it.
 966          */
 967
 968         fsp->mode = psbuf->st_mode;
 969         fsp->inode = psbuf->st_ino;
 970         fsp->dev = psbuf->st_dev;
 971         fsp->size = psbuf->st_size;
 972         fsp->vuid = current_user.vuid;
 973         fsp->pos = -1;
 974         fsp->can_lock = False;
 975         fsp->can_read = False;
 976         fsp->can_write = False;
 977         fsp->share_mode = 0;
 978         fsp->print_file = False;
 979         fsp->modified = False;
 980         fsp->oplock_type = NO_OPLOCK;
 981         fsp->sent_oplock_break = NO_BREAK_SENT;
 982         fsp->is_directory = False;
 983         fsp->stat_open = True;
 984         fsp->directory_delete_on_close = False;
 985         fsp->conn = conn;
 986         string_set(&fsp->fsp_name,fname);
 987         fsp->wcp = NULL; /* Write cache pointer. */
 988
 989         conn->num_files_open++;
 990
 991         return fsp;
 992 }
 993
 994 /****************************************************************************
 995  Open a file for for write to ensure that we can fchmod it.
 996 ****************************************************************************/
 997
 998 files_struct *open_file_fchmod(connection_struct *conn, char *fname, SMB_STRUCT_STAT *psbuf)
 999 {
1000         files_struct *fsp = NULL;
1001         BOOL fsp_open;
1002
1003         if (!VALID_STAT(*psbuf))
1004                 return NULL;
1005
1006         fsp = file_new(conn);
1007         if(!fsp)
1008                 return NULL;
1009
1010         fsp_open = open_file(fsp,conn,fname,psbuf,O_WRONLY,0);
1011
1012         /*
1013          * This is not a user visible file open.
1014          * Don't set a share mode and don't increment
1015          * the conn->num_files_open.
1016          */
1017
1018         if (!fsp_open) {
1019                 file_free(fsp);
1020                 return NULL;
1021         }
1022
1023         return fsp;
1024 }
1025
1026 /****************************************************************************
1027  Close the fchmod file fd - ensure no locks are lost.
1028 ****************************************************************************/
1029
1030 int close_file_fchmod(files_struct *fsp)
1031 {
1032         int ret = fd_close(fsp->conn, fsp);
1033         file_free(fsp);
1034         return ret;
1035 }
1036
1037 /****************************************************************************
1038  Open a directory from an NT SMB call.
1039 ****************************************************************************/
1040
1041 files_struct *open_directory(connection_struct *conn, char *fname,
1042                                                         SMB_STRUCT_STAT *psbuf, int share_mode, int smb_ofun, mode_t unixmode, int *action)
1043 {
1044         extern struct current_user current_user;
1045         BOOL got_stat = False;
1046         files_struct *fsp = file_new(conn);
1047         BOOL delete_on_close = GET_DELETE_ON_CLOSE_FLAG(share_mode);
1048
1049         if(!fsp)
1050                 return NULL;
1051
1052         fsp->conn = conn; /* The vfs_fXXX() macros need this. */
1053
1054         if (VALID_STAT(*psbuf))
1055                 got_stat = True;
1056
1057         if (got_stat && (GET_FILE_OPEN_DISPOSITION(smb_ofun) == FILE_EXISTS_FAIL)) {
1058                 file_free(fsp);
1059                 errno = EEXIST; /* Setup so correct error is returned to client. */
1060                 return NULL;
1061         }
1062
1063         if (GET_FILE_CREATE_DISPOSITION(smb_ofun) == FILE_CREATE_IF_NOT_EXIST) {
1064
1065                 if (got_stat) {
1066
1067                         if(!S_ISDIR(psbuf->st_mode)) {
1068                                 DEBUG(0,("open_directory: %s is not a directory !\n", fname ));
1069                                 file_free(fsp);
1070                                 errno = EACCES;
1071                                 return NULL;
1072                         }
1073                         *action = FILE_WAS_OPENED;
1074
1075                 } else {
1076
1077                         /*
1078                          * Try and create the directory.
1079                          */
1080
1081                         if(!CAN_WRITE(conn)) {
1082                                 DEBUG(2,("open_directory: failing create on read-only share\n"));
1083                                 file_free(fsp);
1084                                 errno = EACCES;
1085                                 return NULL;
1086                         }
1087
1088                         if(vfs_mkdir(conn,fname, unix_mode(conn,aDIR, fname)) < 0) {
1089                                 DEBUG(2,("open_directory: unable to create %s. Error was %s\n",
1090                                          fname, strerror(errno) ));
1091                                 file_free(fsp);
1092                                 return NULL;
1093                         }
1094
1095                         if(vfs_stat(conn,fname, psbuf) != 0) {
1096                                 file_free(fsp);
1097                                 return NULL;
1098                         }
1099
1100                         *action = FILE_WAS_CREATED;
1101
1102                 }
1103         } else {
1104
1105                 /*
1106                  * Don't create - just check that it *was* a directory.
1107                  */
1108
1109                 if(!got_stat) {
1110                         DEBUG(0,("open_directory: unable to stat name = %s. Error was %s\n",
1111                                  fname, strerror(errno) ));
1112                         file_free(fsp);
1113                         return NULL;
1114                 }
1115
1116                 if(!S_ISDIR(psbuf->st_mode)) {
1117                         DEBUG(0,("open_directory: %s is not a directory !\n", fname ));
1118                         file_free(fsp);
1119                         return NULL;
1120                 }
1121
1122                 *action = FILE_WAS_OPENED;
1123         }
1124
1125         DEBUG(5,("open_directory: opening directory %s\n", fname));
1126
1127         /*
1128          * Setup the files_struct for it.
1129          */
1130
1131         fsp->mode = psbuf->st_mode;
1132         fsp->inode = psbuf->st_ino;
1133         fsp->dev = psbuf->st_dev;
1134         fsp->size = psbuf->st_size;
1135         fsp->vuid = current_user.vuid;
1136         fsp->pos = -1;
1137         fsp->can_lock = True;
1138         fsp->can_read = False;
1139         fsp->can_write = False;
1140         fsp->share_mode = share_mode;
1141         fsp->print_file = False;
1142         fsp->modified = False;
1143         fsp->oplock_type = NO_OPLOCK;
1144         fsp->sent_oplock_break = NO_BREAK_SENT;
1145         fsp->is_directory = True;
1146         fsp->directory_delete_on_close = False;
1147         fsp->conn = conn;
1148         string_set(&fsp->fsp_name,fname);
1149
1150         if (delete_on_close) {
1151                 NTSTATUS result = set_delete_on_close_internal(fsp, delete_on_close);
1152
1153                 if (NT_STATUS_V(result) !=  NT_STATUS_V(NT_STATUS_OK)) {
1154                         file_free(fsp);
1155                         return NULL;
1156                 }
1157         }
1158         conn->num_files_open++;
1159
1160         return fsp;
1161 }
1162
1163 /*******************************************************************
1164  Check if the share mode on a file allows it to be deleted or unlinked.
1165  Return True if sharing doesn't prevent the operation.
1166 ********************************************************************/
1167
1168 BOOL check_file_sharing(connection_struct *conn,char *fname, BOOL rename_op)
1169 {
1170   int i;
1171   int ret = False;
1172   share_mode_entry *old_shares = 0;
1173   int num_share_modes;
1174   SMB_STRUCT_STAT sbuf;
1175   pid_t pid = sys_getpid();
1176   SMB_DEV_T dev;
1177   SMB_INO_T inode;
1178
1179   if (vfs_stat(conn,fname,&sbuf) == -1)
1180     return(True);
1181
1182   dev = sbuf.st_dev;
1183   inode = sbuf.st_ino;
1184
1185   lock_share_entry(conn, dev, inode);
1186   num_share_modes = get_share_modes(conn, dev, inode, &old_shares);
1187
1188   /*
1189    * Check if the share modes will give us access.
1190    */
1191
1192   if(num_share_modes != 0)
1193   {
1194     BOOL broke_oplock;
1195
1196     do
1197     {
1198
1199       broke_oplock = False;
1200       for(i = 0; i < num_share_modes; i++)
1201       {
1202         share_mode_entry *share_entry = &old_shares[i];
1203
1204         /*
1205          * Break oplocks before checking share modes. See comment in
1206          * open_file_shared for details.
1207          * Check if someone has an oplock on this file. If so we must
1208          * break it before continuing.
1209          */
1210         if(BATCH_OPLOCK_TYPE(share_entry->op_type))
1211         {
1212
1213 #if 0
1214
1215 /* JRA. Try removing this code to see if the new oplock changes
1216    fix the problem. I'm dubious, but Andrew is recommending we
1217    try this....
1218 */
1219
1220           /*
1221            * It appears that the NT redirector may have a bug, in that
1222            * it tries to do an SMBmv on a file that it has open with a
1223            * batch oplock, and then fails to respond to the oplock break
1224            * request. This only seems to occur when the client is doing an
1225            * SMBmv to the smbd it is using - thus we try and detect this
1226            * condition by checking if the file being moved is open and oplocked by
1227            * this smbd process, and then not sending the oplock break in this
1228            * special case. If the file was open with a deny mode that
1229            * prevents the move the SMBmv will fail anyway with a share
1230            * violation error. JRA.
1231            */
1232           if(rename_op && (share_entry->pid == pid))
1233           {
1234
1235             DEBUG(0,("check_file_sharing: NT redirector workaround - rename attempted on \
1236 batch oplocked file %s, dev = %x, inode = %.0f\n", fname, (unsigned int)dev, (double)inode));
1237
1238             /*
1239              * This next line is a test that allows the deny-mode
1240              * processing to be skipped. This seems to be needed as
1241              * NT insists on the rename succeeding (in Office 9x no less !).
1242              * This should be removed as soon as (a) MS fix the redirector
1243              * bug or (b) NT SMB support in Samba makes NT not issue the
1244              * call (as is my fervent hope). JRA.
1245              */
1246             continue;
1247           }
1248           else
1249 #endif /* 0 */
1250           {
1251
1252             DEBUG(5,("check_file_sharing: breaking oplock (%x) on file %s, \
1253 dev = %x, inode = %.0f\n", share_entry->op_type, fname, (unsigned int)dev, (double)inode));
1254
1255             /* Oplock break.... */
1256             unlock_share_entry(conn, dev, inode);
1257             if(request_oplock_break(share_entry) == False)
1258             {
1259               DEBUG(0,("check_file_sharing: FAILED when breaking oplock (%x) on file %s, \
1260 dev = %x, inode = %.0f\n", old_shares[i].op_type, fname, (unsigned int)dev, (double)inode));
1261
1262               SAFE_FREE(old_shares);
1263               return False;
1264             }
1265             lock_share_entry(conn, dev, inode);
1266             broke_oplock = True;
1267             break;
1268           }
1269         }
1270
1271         /*
1272          * If this is a delete request and ALLOW_SHARE_DELETE is set then allow
1273          * this to proceed. This takes precedence over share modes.
1274          */
1275
1276         if(!rename_op && GET_ALLOW_SHARE_DELETE(share_entry->share_mode))
1277           continue;
1278
1279         /*
1280          * Someone else has a share lock on it, check to see
1281          * if we can too.
1282          */
1283
1284         if ((GET_DENY_MODE(share_entry->share_mode) != DENY_DOS) ||
1285             (share_entry->pid != pid))
1286           goto free_and_exit;
1287
1288       } /* end for */
1289
1290       if(broke_oplock)
1291       {
1292         SAFE_FREE(old_shares);
1293         num_share_modes = get_share_modes(conn, dev, inode, &old_shares);
1294       }
1295     } while(broke_oplock);
1296   }
1297
1298   /* XXXX exactly what share mode combinations should be allowed for
1299      deleting/renaming? */
1300   /*
1301    * If we got here then either there were no share modes or
1302    * all share modes were DENY_DOS and the pid == getpid() or
1303    * delete access was requested and all share modes had the
1304    * ALLOW_SHARE_DELETE bit set (takes precedence over other
1305    * share modes).
1306    */
1307
1308   ret = True;
1309
1310 free_and_exit:
1311
1312   unlock_share_entry(conn, dev, inode);
1313   SAFE_FREE(old_shares);
1314   return(ret);
1315 }