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