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