source3/smbd/open.c

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